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.
784 lines
18 KiB
784 lines
18 KiB
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 := ¶m.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 := ¶m.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 := ¶m.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 := ¶m.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 := ¶m.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 |
|
}
|
|
|