Create & Init Project...

app/admin/main/workflow/http/BUILD

@@ -0,0 +1,53 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "activity.go",
+        "business.go",
+        "callback.go",
+        "challenge.go",
+        "event.go",
+        "group.go",
+        "http.go",
+        "permission.go",
+        "reply.go",
+        "util.go",
+    ],
+    importpath = "go-common/app/admin/main/workflow/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/workflow/model:go_default_library",
+        "//app/admin/main/workflow/model/param:go_default_library",
+        "//app/admin/main/workflow/model/search:go_default_library",
+        "//app/admin/main/workflow/service:go_default_library",
+        "//library/conf/paladin:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/binding:go_default_library",
+        "//library/net/http/blademaster/middleware/permit:go_default_library",
+        "//library/net/http/blademaster/render:go_default_library",
+        "//library/xstr:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/workflow/http/activity.go

@@ -0,0 +1,17 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+func listChallActivity(ctx *bm.Context) {
+	v := &struct {
+		Business int8  `form:"business" validate:"required,gt=0"`
+		Cid      int64 `form:"cid" validate:"required,gt=0"`
+	}{}
+	if err := ctx.Bind(v); err != nil {
+		return
+	}
+
+	ctx.JSON(wkfSvc.ActivityList(ctx, v.Business, v.Cid))
+}

app/admin/main/workflow/http/business.go

@@ -0,0 +1,100 @@
+package http
+
+import (
+	"net/http"
+	"net/url"
+	"strings"
+
+	"go-common/app/admin/main/workflow/model/param"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+	"go-common/library/net/http/blademaster/render"
+)
+
+func busMetaList(ctx *bm.Context) {
+	req := ctx.Request
+	itemType := req.Form.Get("item_type")
+	ctx.JSON(wkfSvc.ListMeta(ctx, itemType))
+}
+
+func listBusAttr(ctx *bm.Context) {
+	ctx.JSON(wkfSvc.ListBusAttr(ctx))
+}
+
+func listBusAttrV3(ctx *bm.Context) {
+	ctx.JSON(wkfSvc.ListBusAttrV3(ctx))
+}
+
+func addOrUpdateBusAttr(ctx *bm.Context) {
+	abap := &param.AddBusAttrParam{}
+	if err := ctx.BindWith(abap, binding.FormPost); err != nil {
+		return
+	}
+	ctx.JSON(nil, wkfSvc.AddOrUpdateBusAttr(ctx, abap))
+}
+
+func setSwitch(ctx *bm.Context) {
+	bs := new(param.BusAttrButtonSwitch)
+	if err := ctx.BindWith(bs, binding.FormPost); err != nil {
+		return
+	}
+	ctx.JSON(nil, wkfSvc.SetSwitch(ctx, bs))
+}
+
+func setShortCut(ctx *bm.Context) {
+	sc := new(param.BusAttrButtonShortCut)
+	if err := ctx.BindWith(sc, binding.FormPost); err != nil {
+		return
+	}
+	if len(sc.ShortCut) != 1 { // only support char
+		ctx.Render(http.StatusOK, render.JSON{
+			Code:    ecode.RequestErr.Code(),
+			Message: "short cut only length 1",
+			Data:    nil,
+		})
+		ctx.Abort()
+		return
+	}
+	sc.ShortCut = strings.ToUpper(sc.ShortCut)
+	ctx.JSON(nil, wkfSvc.SetShortCut(ctx, sc))
+}
+
+func setExtAPI(ctx *bm.Context) {
+	ea := new(param.BusAttrExtAPI)
+	if err := ctx.BindWith(ea, binding.FormPost); err != nil {
+		return
+	}
+	if ea.ExternalAPI != "" {
+		if _, err := url.Parse(ea.ExternalAPI); err != nil {
+			ctx.Render(http.StatusOK, render.JSON{
+				Code:    ecode.RequestErr.Code(),
+				Message: err.Error(),
+				Data:    nil,
+			})
+			ctx.Abort()
+			return
+		}
+	}
+	ctx.JSON(nil, wkfSvc.SetExtAPI(ctx, ea))
+}
+
+func mngTag(ctx *bm.Context) {
+	ctx.JSON(wkfSvc.ManagerTag(ctx))
+}
+
+func userBlockInfo(ctx *bm.Context) {
+	bi := new(param.BlockInfo)
+	if err := ctx.Bind(bi); err != nil {
+		return
+	}
+	ctx.JSON(wkfSvc.UserBlockInfo(ctx, bi))
+}
+
+func srcList(ctx *bm.Context) {
+	src := new(param.Source)
+	if err := ctx.Bind(src); err != nil {
+		return
+	}
+	ctx.JSON(wkfSvc.SourceList(ctx, src))
+}

app/admin/main/workflow/http/callback.go

@@ -0,0 +1,35 @@
+package http
+
+import (
+	"go-common/app/admin/main/workflow/model/param"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func listCallback(ctx *bm.Context) {
+	ctx.JSON(wkfSvc.ListCallback(ctx))
+}
+
+func addOrUpCallback(ctx *bm.Context) {
+	cbp := &param.AddCallbackParam{}
+	if err := ctx.BindWith(cbp, binding.JSON); err != nil {
+		return
+	}
+
+	if cbp.State > 0 {
+		cbp.State = 1
+	}
+
+	cbID, err := wkfSvc.AddOrUpCallback(ctx, cbp)
+	if err != nil {
+		log.Error("wkfSvc.AddUpCallback(%+v) error(%v)", cbp, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	ctx.JSON(map[string]int32{
+		"callbackNo": cbID,
+	}, nil)
+}

app/admin/main/workflow/http/challenge.go

@@ -0,0 +1,784 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/admin/main/workflow/model"
+	"go-common/app/admin/main/workflow/model/param"
+	"go-common/app/admin/main/workflow/model/search"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+	"go-common/library/net/http/blademaster/middleware/permit"
+)
+
+func challList(ctx *bm.Context) {
+	params := ctx.Request.Form
+
+	cidStr := params.Get("cid")
+	gidStr := params.Get("gid")
+	midStr := params.Get("mid")
+	tidStr := params.Get("tid")
+	roundsStr := params.Get("rounds")
+	statesStr := params.Get("states")
+	ctimeFrom := params.Get("ctime_from")
+	ctimeTo := params.Get("ctime_to")
+	order := params.Get("order")
+	sort := params.Get("sort_order")
+	pageStr := params.Get("pn")
+	pagesizeStr := params.Get("ps")
+
+	cc := &search.ChallSearchCommonCond{}
+	numsmap := []*intsParam{
+		{value: cidStr, p: &cc.IDs},
+		{value: gidStr, p: &cc.Gids},
+		{value: midStr, p: &cc.Mids},
+		{value: tidStr, p: &cc.Tids},
+		{value: statesStr, p: &cc.States},
+		{value: roundsStr, p: &cc.Rounds},
+	}
+	var pn, ps int64
+	nummap := []*intParam{
+		{value: pageStr, p: &pn},
+		{value: pagesizeStr, p: &ps},
+	}
+	if err := dealNumsmap(numsmap); err != nil {
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := dealNummap(nummap); err != nil {
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	cc.Order = order
+	if cc.Order == "" {
+		cc.Order = "id"
+	}
+	if cc.Order == "last_time" {
+		cc.Order = "ctime"
+	}
+
+	cc.Sort = adjustOrder("challenge", sort)
+	if cc.Sort != "asc" {
+		cc.Sort = "desc"
+	}
+	if ctimeFrom != "" {
+		cc.CTimeFrom = ctimeFrom
+	}
+	if ctimeTo != "" {
+		cc.CTimeTo = ctimeTo
+	}
+	cc.FormatState()
+	cc.Fields = []string{"id"}
+	cc.PN, _ = strconv.Atoi(pageStr)
+	cc.PS, _ = strconv.Atoi(pagesizeStr)
+	ctx.JSON(wkfSvc.ChallList(ctx, cc))
+}
+
+func challListCommon(ctx *bm.Context) {
+	var (
+		IPers interface{}
+		ok    bool
+		pers  []string
+		err   error
+	)
+	v := new(param.ChallengeListCommonParam)
+	if err = ctx.Bind(v); err != nil {
+		return
+	}
+
+	cc := &search.ChallSearchCommonCond{}
+	cc.Business = v.Business
+	cc.IDs = v.IDs
+	cc.Oids = v.Oids
+	cc.Mids = v.Mids
+	cc.ObjectMids = v.ObjectMids
+	cc.Gids = v.Gids
+	cc.TypeIDs = v.TypeIDs
+	cc.Tids = v.Tids
+	cc.Rounds = v.Rounds
+	cc.AssigneeAdminIDs = v.AssigneeAdminIDs
+	cc.AssigneeAdminNames = v.AssigneeAdminNames
+	cc.AdminIDs = v.AdminIDs
+	cc.CTimeTo = v.CTimeTo
+	cc.CTimeFrom = v.CTimeFrom
+	cc.Order = v.Order
+	cc.Sort = v.Sort
+	cc.States = v.States
+	cc.BusinessStates = v.BusinessStates
+	cc.PN = v.PN
+	cc.PS = v.PS
+	cc.CTimeFrom = v.CTimeFrom
+	cc.CTimeTo = v.CTimeTo
+
+	cc.FormatState()
+
+	if v.Title != "" {
+		cc.KWFields = append(cc.KWFields, "title")
+		cc.KW = append(cc.KW, v.Title)
+	}
+	if v.Content != "" {
+		cc.KWFields = append(cc.KWFields, "content")
+		cc.KW = append(cc.KW, v.Content)
+	}
+
+	if IPers, ok = ctx.Get(permit.CtxPermissions); ok {
+		pers = IPers.([]string)
+	}
+
+	if ok = isPermitChallList(pers, cc); !ok {
+		ctx.JSON(nil, ecode.AccessDenied)
+		ctx.Abort()
+		return
+	}
+	cc.Fields = []string{"id", "gid"}
+	ctx.JSON(wkfSvc.ChallListCommon(ctx, cc))
+}
+
+func challListV3(ctx *bm.Context) {
+	v := new(param.ChallengeListV3Param)
+	if err := ctx.Bind(v); err != nil {
+		return
+	}
+	cc := &search.ChallSearchCommonCond{}
+	cc.Fields = []string{"id", "oid", "mid"}
+	cc.Business = v.Business
+	cc.IDs = v.IDs
+	cc.Oids = v.Oids
+	cc.Mids = v.Mids
+	cc.Gids = v.Gids
+	cc.TypeIDs = v.TypeIDs
+	cc.Tids = v.Tids
+	cc.Rounds = v.Roles
+	cc.AssigneeAdminIDs = v.AssigneeAdminIDs
+	cc.AssigneeAdminNames = v.AssigneeAdminNames
+	cc.AdminIDs = v.AdminIDs
+	cc.CTimeTo = v.CTimeTo
+	cc.CTimeFrom = v.CTimeFrom
+	cc.Order = v.Order
+	cc.Sort = v.Sort
+	cc.States = v.States
+	cc.BusinessStates = v.BusinessStates
+	cc.PN = v.PN
+	cc.PS = v.PS
+	cc.CTimeFrom = v.CTimeFrom
+	cc.CTimeTo = v.CTimeTo
+	cc.KW = v.KW
+	cc.KWFields = v.KWField
+	cc.FormatState()
+
+	ctx.JSON(wkfSvc.ChallListV3(ctx, cc))
+}
+
+func challDetail(ctx *bm.Context) {
+	v := &struct {
+		Cid int64 `form:"cid" validate:"required,gt=0"`
+	}{}
+	if err := ctx.Bind(v); err != nil {
+		return
+	}
+
+	ctx.JSON(wkfSvc.ChallDetail(ctx, v.Cid))
+}
+
+func upChallBusState(ctx *bm.Context) {
+	reqUpFields := &struct {
+		Cid             int64 `form:"cid" json:"cid"`
+		AssigneeAdminid int64 `json:"adminid"`
+		BusState        int8  `form:"business_state" json:"business_state" validate:"min=0,max=14"`
+	}{}
+	if err := ctx.BindWith(reqUpFields, binding.FormPost); err != nil {
+		return
+	}
+	adminID, adminName := adminInfo(ctx)
+
+	ctx.JSON(nil, wkfSvc.UpChallBusState(ctx, reqUpFields.Cid, adminID, adminName, reqUpFields.BusState))
+}
+
+func batchUpChallBusState(ctx *bm.Context) {
+	var (
+		err         error
+		reqUpFields = new(struct {
+			Cids            []int64 `form:"cids,split" json:"cids" validate:"required,gt=0"`
+			AssigneeAdminid int64   `json:"adminid"`
+			BusState        int8    `form:"business_state" json:"business_state" validate:"min=0,max=14"`
+		})
+	)
+	if err = ctx.BindWith(reqUpFields, binding.FormPost); err != nil {
+		return
+	}
+	adminID, adminName := adminInfo(ctx)
+
+	ctx.JSON(nil, wkfSvc.BatchUpChallBusState(ctx, reqUpFields.Cids, adminID, adminName, reqUpFields.BusState))
+}
+
+func upChallBusStateV3(ctx *bm.Context) {
+	bcbsp := new(param.BatchChallBusStateParam)
+	if err := ctx.BindWith(bcbsp, binding.FormPost); err != nil {
+		return
+	}
+	bcbsp.AssigneeAdminID, bcbsp.AssigneeAdminName = adminInfo(ctx)
+	ctx.JSON(nil, wkfSvc.SetChallBusState(ctx, bcbsp))
+}
+
+func upBusChallsBusState(ctx *bm.Context) {
+	var (
+		err         error
+		reqUpFields struct {
+			Business        int8                   `form:"business" json:"business" validate:"required,min=1"`
+			Oid             int64                  `form:"oid" json:"oid" validate:"required,min=1"`
+			AssigneeAdminid int64                  `form:"adminid" json:"adminid" validate:"required,min=1"`
+			State           int8                   `form:"business_state" json:"business_state" validate:"min=0,max=14"`
+			PreStates       []int8                 `form:"pre_business_states" json:"pre_business_states" validate:"dive,gt=-1"` //  business_state修改前的状态
+			Extra           map[string]interface{} `form:"extra" json:"extra"`
+		}
+	)
+
+	if err = ctx.BindWith(&reqUpFields, binding.JSON); err != nil {
+		log.Error("/business/busState/update bind failed error(%v)", err)
+		return
+	}
+
+	if len(reqUpFields.PreStates) <= 0 {
+		reqUpFields.PreStates = append(reqUpFields.PreStates, int8(0))
+	}
+
+	upCids, err := wkfSvc.UpBusChallsBusState(ctx, reqUpFields.Business, reqUpFields.State, reqUpFields.PreStates, reqUpFields.Oid, reqUpFields.AssigneeAdminid, reqUpFields.Extra)
+
+	log.Info("call upBusChallsBusState param(%v) upcids(%v)", reqUpFields, upCids)
+	ctx.JSON(map[string]interface{}{"cids": upCids}, err)
+}
+
+func setChallResult(ctx *bm.Context) {
+	crp := &param.ChallResParam{}
+	if err := ctx.BindWith(crp, binding.FormPost); err != nil {
+		return
+	}
+	crp.AdminID, crp.AdminName = adminInfo(ctx)
+
+	ctx.JSON(nil, wkfSvc.SetChallResult(ctx, crp))
+}
+
+func batchSetChallResult(ctx *bm.Context) {
+	bcrp := &param.BatchChallResParam{}
+	if err := ctx.BindWith(bcrp, binding.FormPost); err != nil {
+		return
+	}
+	bcrp.AdminID, bcrp.AdminName = adminInfo(ctx)
+
+	ctx.JSON(nil, wkfSvc.BatchSetChallResult(ctx, bcrp))
+}
+
+func setChallStateV3(ctx *bm.Context) {
+	bcrp := &param.BatchChallResParam{}
+	if err := ctx.BindWith(bcrp, binding.FormPost); err != nil {
+		return
+	}
+	bcrp.AdminID, bcrp.AdminName = adminInfo(ctx)
+	ctx.JSON(nil, wkfSvc.BatchSetChallResult(ctx, bcrp))
+}
+
+func rstChallResult(ctx *bm.Context) {
+	crp := new(param.ChallRstParam)
+	if err := ctx.BindWith(crp, binding.FormPost); err != nil {
+		return
+	}
+	crp.AdminID, crp.AdminName = adminInfo(ctx)
+	//force to pending
+	crp.State = model.Pending
+	ctx.JSON(nil, wkfSvc.RstChallResult(ctx, crp))
+}
+
+func rstChallResultV3(ctx *bm.Context) {
+	crp := new(param.ChallRstParam)
+	if err := ctx.BindWith(crp, binding.FormPost); err != nil {
+		return
+	}
+	crp.AdminID, crp.AdminName = adminInfo(ctx)
+	// TODO(zhoujiahui): force to pending now
+	crp.State = model.Pending
+	ctx.JSON(nil, wkfSvc.RstChallResult(ctx, crp))
+}
+
+func upChallExtra(ctx *bm.Context) {
+	cep := &param.ChallExtraParam{}
+	if err := ctx.BindWith(cep, binding.JSON); err != nil {
+		return
+	}
+	cep.AdminID, cep.AdminName = adminInfo(ctx)
+	ctx.JSON(nil, wkfSvc.UpChallExtraV2(ctx, cep))
+}
+
+func upChallExtraV3(ctx *bm.Context) {
+	cep3 := &param.ChallExtraParamV3{}
+	if err := ctx.BindWith(cep3, binding.Form); err != nil {
+		return
+	}
+	cep3.AdminID, cep3.AdminName = adminInfo(ctx)
+	ctx.JSON(nil, wkfSvc.UpChallExtraV3(ctx, cep3))
+}
+
+func batchUpChallExtra(ctx *bm.Context) {
+	bcep := new(param.BatchChallExtraParam)
+	if err := ctx.BindWith(bcep, binding.JSON); err != nil {
+		return
+	}
+	bcep.AdminID, bcep.AdminName = adminInfo(ctx)
+
+	ctx.JSON(nil, wkfSvc.BatchUpChallExtraV2(ctx, bcep))
+}
+
+func listChallBusiness(ctx *bm.Context) {
+	v := new(struct {
+		Cids []int64 `form:"cids,split" validate:"required,gt=0"`
+	})
+	if err := ctx.Bind(v); err != nil {
+		return
+	}
+	ctx.JSON(wkfSvc.BusinessList(ctx, v.Cids))
+}
+
+func upChall(ctx *bm.Context) {
+	cup := new(param.ChallUpParam)
+	if err := ctx.BindWith(cup, binding.FormPost); err != nil {
+		return
+	}
+	cup.AdminID, cup.AdminName = adminInfo(ctx)
+	ctx.JSON(nil, wkfSvc.UpChall(ctx, cup))
+}
+
+func upChallV3(ctx *bm.Context) {
+	cup := new(param.ChallUpParam)
+	if err := ctx.BindWith(cup, binding.FormPost); err != nil {
+		return
+	}
+	cup.AdminID, cup.AdminName = adminInfo(ctx)
+	ctx.JSON(nil, wkfSvc.UpChall(ctx, cup))
+}
+
+func platformChallCount(ctx *bm.Context) {
+	var (
+		assigneeAdminID int64
+		ok              bool
+		IUid            interface{}
+		IPers           interface{}
+		permissionMap   map[int8]int64
+	)
+	if IUid, ok = ctx.Get("uid"); ok {
+		assigneeAdminID = IUid.(int64)
+	}
+
+	if IPers, ok = ctx.Get(permit.CtxPermissions); ok {
+		permissionMap = parsePermission(IPers.([]string))
+	}
+
+	ctx.JSON(wkfSvc.PlatformChallCount(ctx, assigneeAdminID, permissionMap))
+}
+
+func platformChallListPending(ctx *bm.Context) {
+	var (
+		err             error
+		pclp            *param.ChallListParam
+		assigneeAdminID int64
+		ok              bool
+		IPers           interface{}
+		IUid            interface{}
+		permissionMap   map[int8]int64
+	)
+	pclp = new(param.ChallListParam)
+	if err = ctx.Bind(pclp); err != nil {
+		return
+	}
+	if len(pclp.Businesses) != len(pclp.AssignNum) {
+		ctx.JSON("business and AssignNum length not equal", ecode.RequestErr)
+		return
+	}
+	if pclp.PS == 0 {
+		pclp.PS = 10
+	}
+
+	if IUid, ok = ctx.Get("uid"); ok {
+		assigneeAdminID = IUid.(int64)
+	}
+
+	if IPers, ok = ctx.Get(permit.CtxPermissions); ok {
+		permissionMap = parsePermission(IPers.([]string))
+	}
+
+	ctx.JSON(wkfSvc.PlatformChallListPending(ctx, assigneeAdminID, permissionMap, pclp))
+}
+
+func platformHandlingChalllist(ctx *bm.Context) {
+	var (
+		err             error
+		assigneeAdminID int64
+		ok              bool
+		permissionMap   map[int8]int64
+		IUid            interface{}
+		IPers           interface{}
+	)
+	chdlp := new(param.ChallHandlingDoneListParam)
+	if err = ctx.Bind(chdlp); err != nil {
+		return
+	}
+
+	if IUid, ok = ctx.Get("uid"); ok {
+		assigneeAdminID = IUid.(int64)
+	}
+
+	if IPers, ok = ctx.Get(permit.CtxPermissions); ok {
+		permissionMap = parsePermission(IPers.([]string))
+	}
+
+	ctx.JSON(wkfSvc.PlatformChallListHandlingDone(ctx, chdlp, permissionMap, assigneeAdminID, model.PlatformStateHandling))
+}
+
+func platformDoneChallList(ctx *bm.Context) {
+	var (
+		err             error
+		assigneeAdminID int64
+		ok              bool
+		permissionMap   map[int8]int64
+		IUid            interface{}
+		IPers           interface{}
+	)
+	chdlp := new(param.ChallHandlingDoneListParam)
+	if err = ctx.Bind(chdlp); err != nil {
+		return
+	}
+	if IUid, ok = ctx.Get("uid"); ok {
+		assigneeAdminID = IUid.(int64)
+	}
+
+	if IPers, ok = ctx.Get(permit.CtxPermissions); ok {
+		permissionMap = parsePermission(IPers.([]string))
+	}
+	ctx.JSON(wkfSvc.PlatformChallListHandlingDone(ctx, chdlp, permissionMap, assigneeAdminID, model.PlatformStateDone))
+}
+
+func platformCreatedChallList(ctx *bm.Context) {
+	var (
+		err     error
+		cclp    *param.ChallCreatedListParam
+		adminID int64
+		IUid    interface{}
+		ok      bool
+	)
+
+	cclp = new(param.ChallCreatedListParam)
+	if err = ctx.Bind(cclp); err != nil {
+		return
+	}
+	if cclp.PS == 0 {
+		cclp.PS = 10
+	}
+
+	if IUid, ok = ctx.Get("uid"); ok {
+		adminID = IUid.(int64)
+	}
+
+	cond := new(search.ChallSearchCommonCond)
+	cond.Fields = []string{"id", "gid"}
+	cond.Business = cclp.Businesses
+	cond.AdminIDs = []int64{adminID}
+	cond.Order = cclp.Order
+	cond.Sort = cclp.Sort
+	cond.PS = cclp.PS
+	cond.PN = cclp.PN
+
+	ctx.JSON(wkfSvc.PlatformChallListCreated(ctx, cond))
+
+}
+
+func platformRelease(ctx *bm.Context) {
+	var (
+		exist           bool
+		IUid            interface{}
+		IPers           interface{}
+		permissionMap   map[int8]int64
+		assigneeAdminID int64
+	)
+	if IUid, exist = ctx.Get("uid"); !exist {
+		ctx.JSON(nil, ecode.UserNotExist)
+		return
+	}
+	assigneeAdminID = IUid.(int64)
+
+	if IPers, exist = ctx.Get(permit.CtxPermissions); !exist {
+		ctx.JSON(nil, ecode.MethodNoPermission)
+		return
+	}
+	permissionMap = parsePermission(IPers.([]string))
+	ctx.JSON(nil, wkfSvc.PlatformRelease(ctx, permissionMap, assigneeAdminID))
+}
+
+func platformCheckIn(ctx *bm.Context) {
+	var (
+		exist           bool
+		IUid            interface{}
+		assigneeAdminID int64
+	)
+	if IUid, exist = ctx.Get("uid"); !exist {
+		ctx.JSON(nil, ecode.UserNotExist)
+		return
+	}
+	assigneeAdminID = IUid.(int64)
+
+	ctx.JSON(nil, wkfSvc.PlatformCheckIn(ctx, assigneeAdminID))
+}
+
+func isPermitChallList(pers []string, cond *search.ChallSearchCommonCond) (ok bool) {
+	if cond.Business == 0 {
+		return
+	}
+	var (
+		business int8
+		round    int64
+	)
+	if len(cond.Rounds) != 0 {
+		round = cond.Rounds[0]
+	}
+	business = cond.Business
+
+	switch business {
+	case 2: //稿件申诉
+		switch round {
+		case 0:
+			for _, per := range pers {
+				if per == ArchiveAppealRound1 {
+					cond.Rounds = append(cond.Rounds, 1)
+					ok = true
+				}
+				if per == ArchiveAppealRound2 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+				if per == ArchiveAppealRound3 {
+					cond.Rounds = append(cond.Rounds, 3)
+					ok = true
+				}
+			}
+		case 1:
+			for _, per := range pers {
+				if per == ArchiveAppealRound1 {
+					cond.Rounds = append(cond.Rounds, 1)
+					ok = true
+				}
+			}
+		case 2:
+			for _, per := range pers {
+				if per == ArchiveAppealRound2 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+			}
+		case 3:
+			for _, per := range pers {
+				if per == ArchiveAppealRound3 {
+					cond.Rounds = append(cond.Rounds, 3)
+					ok = true
+				}
+			}
+		}
+
+	case 3: // 短点评投诉
+		switch round {
+		case 0:
+			for _, per := range pers {
+				if per == ReviewShortComplainRoun1 {
+					cond.Rounds = append(cond.Rounds, 1)
+					ok = true
+				}
+				if per == ReviewShortComplainRoun2 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+			}
+		case 1:
+			for _, per := range pers {
+				if per == ReviewShortComplainRoun1 {
+					cond.Rounds = append(cond.Rounds, 1)
+					ok = true
+				}
+			}
+		case 2:
+			for _, per := range pers {
+				if per == ReviewShortComplainRoun2 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+			}
+		}
+	case 4: // 长点评投诉
+		switch round {
+		case 0:
+			for _, per := range pers {
+				if per == ReviewLongComplainRoun1 {
+					cond.Rounds = append(cond.Rounds, 1)
+					ok = true
+				}
+				if per == ReviewLongComplainRoun2 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+			}
+		case 1:
+			for _, per := range pers {
+				if per == ReviewLongComplainRoun1 {
+					cond.Rounds = append(cond.Rounds, 1)
+					ok = true
+				}
+			}
+		case 2:
+			for _, per := range pers {
+				if per == ReviewLongComplainRoun2 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+			}
+		}
+	case 5: // 小黑屋申诉
+		switch round {
+		case 0:
+			for _, per := range pers {
+				if per == CreditAppealRoun1 {
+					cond.Rounds = append(cond.Rounds, 1)
+					ok = true
+				}
+				if per == CreditAppealRoun2 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+				if per == CreditAppealRoun3 {
+					cond.Rounds = append(cond.Rounds, 3)
+					ok = true
+				}
+				if per == CreditAppealRoun4 {
+					cond.Rounds = append(cond.Rounds, 4)
+					ok = true
+				}
+				if per == CreditAppealRoun5 {
+					cond.Rounds = append(cond.Rounds, 5)
+					ok = true
+				}
+				if per == CreditAppealRoun6 {
+					cond.Rounds = append(cond.Rounds, 6)
+					ok = true
+				}
+				if per == CreditAppealRoun7 {
+					cond.Rounds = append(cond.Rounds, 7)
+					ok = true
+				}
+				if per == CreditAppealRoun8 {
+					cond.Rounds = append(cond.Rounds, 8)
+					ok = true
+				}
+			}
+		case 1:
+			for _, per := range pers {
+				if per == CreditAppealRoun1 {
+					cond.Rounds = append(cond.Rounds, 1)
+					ok = true
+				}
+			}
+		case 2:
+			for _, per := range pers {
+				if per == CreditAppealRoun2 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+			}
+		case 3:
+			for _, per := range pers {
+				if per == CreditAppealRoun3 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+			}
+		case 4:
+			for _, per := range pers {
+				if per == CreditAppealRoun4 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+			}
+		case 5:
+			for _, per := range pers {
+				if per == CreditAppealRoun5 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+			}
+		case 6:
+			for _, per := range pers {
+				if per == CreditAppealRoun6 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+			}
+		case 7:
+			for _, per := range pers {
+				if per == CreditAppealRoun7 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+			}
+		case 8:
+			for _, per := range pers {
+				if per == CreditAppealRoun8 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+			}
+		}
+	case 6: // 稿件审核
+		switch round {
+		case 0:
+			for _, per := range pers {
+				if per == ArchiveAuditRound1 {
+					cond.Rounds = append(cond.Rounds, 1)
+					ok = true
+				}
+			}
+		case 1:
+			for _, per := range pers {
+				if per == ArchiveAuditRound1 {
+					cond.Rounds = append(cond.Rounds, 1)
+					ok = true
+				}
+			}
+		}
+	case 9: //频道举报
+		switch round {
+		case 0:
+			for _, per := range pers {
+				if per == ChannelComplainRound1 {
+					cond.Rounds = append(cond.Rounds, 1)
+					ok = true
+				}
+				if per == ChannelComplainRound1 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+			}
+		case 1:
+			for _, per := range pers {
+				if per == ChannelComplainRound1 {
+					cond.Rounds = append(cond.Rounds, 1)
+					ok = true
+				}
+			}
+		case 2:
+			for _, per := range pers {
+				if per == ChannelComplainRound2 {
+					cond.Rounds = append(cond.Rounds, 2)
+					ok = true
+				}
+			}
+		}
+	}
+
+	return
+}

app/admin/main/workflow/http/event.go

@@ -0,0 +1,68 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/admin/main/workflow/model/param"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func addEvent(ctx *bm.Context) {
+	ep := &param.EventParam{}
+	if err := ctx.BindWith(ep, binding.JSON); err != nil {
+		return
+	}
+
+	if !ep.ValidComponent() {
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	eid, err := wkfSvc.AddEvent(ctx, ep)
+	if err != nil {
+		log.Error("wkfSvc.AddEvent(%v) error(%v)", ep, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	ctx.JSON(map[string]int64{
+		"eventNo": eid,
+	}, nil)
+}
+
+func batchAddEvent(ctx *bm.Context) {
+	bep := &param.BatchEventParam{}
+	if err := ctx.BindWith(bep, binding.JSON); err != nil {
+		return
+	}
+
+	if !bep.ValidComponent() {
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	eids, err := wkfSvc.BatchAddEvent(ctx, bep)
+	if err != nil {
+		log.Error("wkfSvc.BatchAddEvent(%v) error(%v)", bep, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	ctx.JSON(map[string][]int64{
+		"eventNo": eids,
+	}, nil)
+}
+
+func eventList(ctx *bm.Context) {
+	params := ctx.Request.Form
+	cidStr := params.Get("cid")
+	// check params
+	cid, err := strconv.ParseInt(cidStr, 10, 32)
+	if err != nil {
+		log.Error("strconv.ParseInt(%s) error(%v)", cidStr, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	ctx.JSON(wkfSvc.ListEvent(ctx, cid))
+}

app/admin/main/workflow/http/group.go

@@ -0,0 +1,107 @@
+package http
+
+import (
+	"go-common/app/admin/main/workflow/model"
+	"go-common/app/admin/main/workflow/model/param"
+	"go-common/app/admin/main/workflow/model/search"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func setGroupStateV3(ctx *bm.Context) {
+	gssp := &param.GroupStateSetParam{}
+	if err := ctx.BindWith(gssp, binding.FormPost); err != nil {
+		return
+	}
+	gssp.AdminID, gssp.AdminName = adminInfo(ctx)
+
+	// check ban account operate    账号封禁不支持批处理
+	if len(gssp.ID) > 1 && gssp.BlockDay != 0 {
+		ctx.JSON(nil, ecode.WkfBanNotSupportBatchOperate)
+		return
+	}
+
+	ctx.JSON(nil, wkfSvc.SetGroupState(ctx, gssp))
+}
+
+func groupListV3(ctx *bm.Context) {
+	v := new(param.GroupListParamV3)
+	if err := ctx.Bind(v); err != nil {
+		return
+	}
+	gscc := &search.GroupSearchCommonCond{
+		Fields:       []string{"id", "oid", "typeid", "mid", "eid", "report_mid", "title", "first_user_tid"},
+		Business:     v.Business,
+		Oids:         v.Oid,
+		Mids:         v.Mid,
+		States:       v.State,
+		TypeIDs:      v.TypeID,
+		Rounds:       v.Round,
+		RID:          v.Rid,
+		FID:          v.Fid,
+		EID:          v.Eid,
+		Tids:         v.Tid,
+		FirstUserTid: v.FirstUserTid,
+		Order:        v.Order,
+		Sort:         v.Sort,
+		PN:           v.PN,
+		PS:           v.PS,
+		KWPriority:   v.KWPriority,
+		KW:           v.KW,
+		KWFields:     v.KWField,
+		CTimeFrom:    v.CTimeFrom,
+		CTimeTo:      v.CTimeTo,
+		ReportMID:    v.ReportMid,
+	}
+	ctx.JSON(wkfSvc.GroupListV3(ctx, gscc))
+}
+
+func setGroupRole(ctx *bm.Context) {
+	grsp := &param.GroupRoleSetParam{}
+	if err := ctx.BindWith(grsp, binding.FormPost); err != nil {
+		return
+	}
+	grsp.AdminID, grsp.AdminName = adminInfo(ctx)
+	ctx.JSON(nil, wkfSvc.UpGroupRole(ctx, grsp))
+}
+
+func upGroupExtra(ctx *bm.Context) {
+	uep := &param.UpExtraParam{}
+	if err := ctx.BindWith(uep, binding.Form); err != nil {
+		return
+	}
+	uep.AdminID, uep.AdminName = adminInfo(ctx)
+	ctx.JSON(nil, wkfSvc.UpGroupExtra(ctx, uep))
+}
+
+func setPublicReferee(ctx *bm.Context) {
+	gspr := &param.GroupStatePublicReferee{}
+	if err := ctx.BindWith(gspr, binding.FormPost); err != nil {
+		return
+	}
+	// if bid support public judge
+	if gspr.Business != model.CommentComplain {
+		ctx.JSON(nil, ecode.WkfBidNotSupportPublicReferee)
+	}
+	gspr.AdminID, gspr.AdminName = adminInfo(ctx)
+	ctx.JSON(nil, wkfSvc.SetPublicReferee(ctx, gspr))
+}
+
+func countPendingGroup(ctx *bm.Context) {
+	gpp := &param.GroupPendingParam{}
+	if err := ctx.Bind(gpp); err != nil {
+		return
+	}
+	gscc := &search.GroupSearchCommonCond{
+		Fields:   []string{"id"},
+		Business: gpp.Business,
+		RID:      gpp.Rid,
+		States:   []int8{model.Pending},
+		PS:       1,
+		PN:       1,
+		Order:    "id",
+		Sort:     "desc",
+	}
+	ctx.JSON(wkfSvc.GroupPendingCount(ctx, gscc))
+}

app/admin/main/workflow/http/http.go

@@ -0,0 +1,167 @@
+package http
+
+import (
+	"go-common/app/admin/main/workflow/service"
+	"go-common/library/conf/paladin"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/permit"
+)
+
+var (
+	authSvc *permit.Permit
+	wkfSvc  *service.Service
+)
+
+// Init http server
+func Init(s *service.Service) {
+	var (
+		hc struct {
+			BM     *bm.ServerConfig
+			Permit *permit.Config
+		}
+	)
+	if err := paladin.Get("http.toml").UnmarshalTOML(&hc); err != nil {
+		panic(err)
+	}
+	// init service
+	iniService(hc.Permit, s)
+	// init internal router
+	engine := bm.DefaultServer(hc.BM)
+	//global timeout
+	setupInnerEngine(engine)
+	// init internal server
+	if err := engine.Start(); err != nil {
+		log.Error("engine.Start error(%v)", err)
+		panic(err)
+	}
+}
+
+func iniService(auth *permit.Config, s *service.Service) {
+	authSvc = permit.New(auth)
+	wkfSvc = s
+}
+
+// innerRouter
+func setupInnerEngine(e *bm.Engine) {
+	// monitor ping
+	e.Ping(ping)
+
+	workflow := e.Group("/x/admin/workflow")
+
+	// platform
+	platform := workflow.Group("/platform", authSvc.Permit(""))
+	{
+		platform.GET("/count", platformChallCount)
+		platform.GET("/list/pending", platformChallListPending)
+		platform.GET("/list/handling", platformHandlingChalllist)
+		platform.GET("/list/done", platformDoneChallList)
+		platform.GET("/list/created", platformCreatedChallList)
+		platform.GET("/release", platformRelease)
+		platform.GET("/checkin", platformCheckIn)
+	}
+
+	// challenge
+	challenge := workflow.Group("/challenge")
+	{
+		challenge.GET("/list", challList)
+		challenge.GET("/list2", authSvc.Permit(""), challListCommon)
+		challenge.GET("/detail", challDetail)
+		challenge.GET("/activity/list", listChallActivity)
+		challenge.GET("/business/list", listChallBusiness) // Deprecated
+		challenge.POST("/update", authSvc.Permit(""), upChall)
+		challenge.POST("/reset", authSvc.Permit(""), rstChallResult)
+		challenge.POST("/state/set", authSvc.Permit(""), setChallResult)             // new api logic
+		challenge.POST("/state/batch/set", authSvc.Permit(""), batchSetChallResult)  //new api logic
+		challenge.POST("/batch/result/set", authSvc.Permit(""), batchSetChallResult) // todo: deprecated
+		challenge.POST("/extra/update", authSvc.Permit(""), upChallExtra)
+		challenge.POST("/extra/batch/update", authSvc.Permit(""), batchUpChallExtra)
+		challenge.POST("/business/state/set", authSvc.Permit(""), upChallBusState)
+		challenge.POST("/business/state/batch/set", authSvc.Permit(""), batchUpChallBusState)
+
+		// manager-v4 used
+		challenge.POST("/business/busState/update", upBusChallsBusState) //Deprecated
+		challenge.POST("/reset/business/state/batch/set", upBusChallsBusState)
+
+		// challenge event
+		event := challenge.Group("/event")
+		event.POST("/add", addEvent)
+		event.POST("/batch/add", batchAddEvent)
+		event.GET("/list", eventList)
+
+		// call reply/add sync add event and set business_state
+		reply := challenge.Group("/reply")
+		reply.POST("/add", authSvc.Permit(""), addReply)
+		reply.POST("/batch/add", authSvc.Permit(""), batchAddReply)
+	}
+
+	// business
+	business := workflow.Group("/business")
+	{
+		business.GET("/meta/list", busMetaList)
+
+		// callback
+		callback := business.Group("/callback")
+		{
+			callback.GET("/list", listCallback)
+			callback.POST("/add", authSvc.Permit(""), addOrUpCallback)
+			callback.POST("/external/api/set", setExtAPI)
+		}
+
+		// attr
+		busAttr := business.Group("/attr")
+		{
+			busAttr.GET("/list", listBusAttr)
+			busAttr.POST("/add", addOrUpdateBusAttr)
+		}
+	}
+
+	// todo: workflow_v3
+	v3 := workflow.Group("/v3")
+	challenge3 := v3.Group("/challenge", authSvc.Permit(""))
+	{
+		challenge3.GET("/list", challListV3)
+		challenge3.POST("/update", upChallV3)
+		challenge3.POST("/reset", rstChallResultV3)
+		challenge3.POST("/state/set", setChallStateV3)
+		challenge3.POST("/business/state/set", upChallBusStateV3)
+		challenge3.POST("/extra/update", upChallExtraV3)
+	}
+	group3 := v3.Group("/group", authSvc.Permit(""))
+	{
+		group3.GET("/list", groupListV3)
+		group3.GET("/pending/count", countPendingGroup)
+		group3.POST("/role/set", setGroupRole)     //角色流转
+		group3.POST("/state/set", setGroupStateV3) //工单状态变更/处罚
+		group3.POST("/extra/update", upGroupExtra)
+		group3.POST("/public/referee/set", setPublicReferee) //移交众裁
+	}
+
+	bus3 := v3.Group("/business")
+	{
+		attr3 := bus3.Group("/attr")
+		{
+			attr3.GET("/list", listBusAttrV3)
+			attr3.POST("/button/switch", setSwitch)
+			attr3.POST("/button/shortcut/set", setShortCut)
+		}
+		mng := bus3.Group("/manager")
+		{
+			mng.GET("/tag", mngTag)
+		}
+		source := bus3.Group("/source")
+		{
+			source.GET("/list", srcList)
+		}
+	}
+
+	v3.GET("/user/block/info", userBlockInfo) //单个用户封禁次数/封禁状态
+}
+
+// ping check server ok.
+func ping(ctx *bm.Context) {
+	if err := wkfSvc.Ping(ctx); err != nil {
+		ctx.Error = err
+		ctx.AbortWithStatus(503)
+	}
+}

app/admin/main/workflow/http/permission.go

@@ -0,0 +1,34 @@
+package http
+
+// permission point
+const (
+	ArchiveComplainRound1 = "WF_ARCHIVE_COMPLAIN_ROUND_1"
+	ArchiveComplainRound2 = "WF_ARCHIVE_COMPLAIN_ROUND_2"
+
+	ArchiveAppealRound1 = "WF_ARCHIVE_APPEAL_ROUND_1"
+	ArchiveAppealRound2 = "WF_ARCHIVE_APPEAL_ROUND_2"
+	ArchiveAppealRound3 = "WF_ARCHIVE_APPEAL_ROUND_3"
+	ArchiveAppealRepeat = "WF_BUSINESS_2_ROUND_11"
+
+	ReviewShortComplainRoun1 = "WF_BUSINESS_3_ROUND_1"
+	ReviewShortComplainRoun2 = "WF_BUSINESS_3_ROUND_2"
+
+	ReviewLongComplainRoun1 = "WF_BUSINESS_4_ROUND_1"
+	ReviewLongComplainRoun2 = "WF_BUSINESS_4_ROUND_2"
+
+	CreditAppealRoun1 = "WF_BUSINESS_5_ROUND_1"
+	CreditAppealRoun2 = "WF_BUSINESS_5_ROUND_2"
+	CreditAppealRoun3 = "WF_BUSINESS_5_ROUND_3"
+	CreditAppealRoun4 = "WF_BUSINESS_5_ROUND_4"
+	CreditAppealRoun5 = "WF_BUSINESS_5_ROUND_5"
+	CreditAppealRoun6 = "WF_BUSINESS_5_ROUND_6"
+	CreditAppealRoun7 = "WF_BUSINESS_5_ROUND_7"
+	CreditAppealRoun8 = "WF_BUSINESS_5_ROUND_8"
+
+	ArchiveAuditRound1 = "WF_BUSINESS_6_ROUND_1"
+
+	ArchiveVTRound1 = "WF_BUSINESS_7_ROUND_1"
+
+	ChannelComplainRound1 = "WF_BUSINESS_8_ROUND_1"
+	ChannelComplainRound2 = "WF_BUSINESS_8_ROUND_2"
+)

app/admin/main/workflow/http/reply.go

@@ -0,0 +1,71 @@
+package http
+
+import (
+	"go-common/app/admin/main/workflow/model"
+	"go-common/app/admin/main/workflow/model/param"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func addReply(ctx *bm.Context) {
+	var (
+		eid int64
+		err error
+	)
+
+	e := &param.EventParam{}
+	if err = ctx.BindWith(e, binding.FormPost); err != nil {
+		return
+	}
+	e.AdminID, e.AdminName = adminInfo(ctx)
+
+	if eid, err = wkfSvc.AddEvent(ctx, e); err != nil {
+		ctx.JSON(nil, err)
+		return
+	}
+
+	// 管理员回复同步修改 business_state
+	if e.Event == 1 {
+		if err = wkfSvc.UpChallBusState(ctx, e.Cid, e.AdminID, e.AdminName, model.FeedbackReplyNotRead); err != nil {
+			ctx.JSON(nil, err)
+			return
+		}
+	}
+
+	ctx.JSON(map[string]int64{
+		"eventNo": eid,
+	}, nil)
+}
+
+func batchAddReply(ctx *bm.Context) {
+	var (
+		eids []int64
+		err  error
+	)
+	bep := &param.BatchEventParam{}
+	if err = ctx.BindWith(bep, binding.FormPost); err != nil {
+		return
+	}
+	bep.AdminID, bep.AdminName = adminInfo(ctx)
+
+	eids, err = wkfSvc.BatchAddEvent(ctx, bep)
+	if err != nil {
+		log.Error("wkfSvc.BatchAddEvent(%v) error(%v)", bep, err)
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	// 管理员回复同步修改 business_state
+	if bep.Event == 1 {
+		if err = wkfSvc.BatchUpChallBusState(ctx, bep.Cids, bep.AdminID, bep.AdminName, model.FeedbackReplyNotRead); err != nil {
+			ctx.JSON(nil, err)
+			return
+		}
+	}
+
+	ctx.JSON(map[string][]int64{
+		"eventNo": eids,
+	}, nil)
+}

app/admin/main/workflow/http/util.go

@@ -0,0 +1,119 @@
+package http
+
+import (
+	"strconv"
+	"strings"
+
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/xstr"
+)
+
+type intsParam struct {
+	value string
+	p     *[]int64
+}
+type intParam struct {
+	value string
+	p     *int64
+}
+
+func dealNumsmap(intsparams []*intsParam) error {
+	for _, isp := range intsparams {
+		if isp.value != "" {
+			ids, err := xstr.SplitInts(isp.value)
+			if err != nil {
+				log.Error("strconv.ParseInt(%s) error(%v)", isp.value, err)
+				return err
+			}
+			*isp.p = ids
+		}
+	}
+
+	return nil
+}
+
+func dealNummap(intparams []*intParam) error {
+	for _, ip := range intparams {
+		if ip.value != "" {
+			id, err := strconv.ParseInt(ip.value, 10, 64)
+			if err != nil {
+				log.Error("strconv.ParseInt(%s) error(%v)", ip.value, err)
+				return err
+			}
+			*ip.p = id
+		}
+	}
+
+	return nil
+}
+
+// adjustOrder will convert order field from request to search service
+func adjustOrder(subject string, order string) string {
+	SubOrderFields := map[string]map[string]string{
+		"group": {
+			"last_time": "lasttime",
+		},
+
+		"tag": {
+			"count":    "tag_all_num",
+			"handling": "tag_todo_num",
+		},
+
+		"challenge": {},
+
+		"log": {
+			"ctime": "opt_ctime",
+		},
+	}
+
+	orderFields, ok := SubOrderFields[subject]
+	if !ok {
+		return order
+	}
+
+	field, ok := orderFields[order]
+	if !ok {
+		return order
+	}
+
+	return field
+}
+
+// read permissions of an admin
+// only use workflow permissions in platform
+// like WF_BUSINESS_2_ROUND_11
+// round > 10 means feedback flow
+// one admin only has one flow permission in a business
+func parsePermission(permissions []string) (permissionMap map[int8]int64) {
+	//permissionMap map[business]round
+	//var regex = `^WF_BUSINESS_[1-9]\d*_ROUND_[1-9]\d*`
+	permissionMap = make(map[int8]int64)
+	for _, str := range permissions {
+		splitStr := strings.Split(str, "_")
+		if len(splitStr) == 5 && splitStr[0] == "WF" && splitStr[1] == "BUSINESS" && splitStr[3] == "ROUND" {
+			business, err := strconv.ParseInt(splitStr[2], 10, 32)
+			if err != nil {
+				continue
+			}
+			round, err := strconv.ParseInt(splitStr[4], 10, 32)
+			if err != nil {
+				continue
+			}
+			permissionMap[int8(business)] = round
+			//todo: support round??
+		}
+	}
+	// todo: use cache?
+	return
+}
+
+func adminInfo(ctx *bm.Context) (adminID int64, adminName string) {
+	if IUid, ok := ctx.Get("uid"); ok {
+		adminID = IUid.(int64)
+	}
+	if IUName, ok := ctx.Get("username"); ok {
+		adminName = IUName.(string)
+	}
+	return
+}