1094 lines
29 KiB
Go
1094 lines
29 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"strconv"
|
||
"time"
|
||
|
||
"go-common/app/admin/main/workflow/model"
|
||
"go-common/app/admin/main/workflow/model/param"
|
||
credit "go-common/app/job/main/credit/model"
|
||
"go-common/library/log"
|
||
"go-common/library/queue/databus/report"
|
||
xtime "go-common/library/time"
|
||
)
|
||
|
||
func (s *Service) afterSetGrpResult(grp *param.GroupResParam, g *model.Group, tinyChalls map[int64]*model.TinyChall) {
|
||
logging := func() {
|
||
// write group log
|
||
l := &model.WLog{
|
||
AdminID: grp.AdminID,
|
||
Admin: grp.AdminName,
|
||
Oid: g.Oid,
|
||
Business: g.Business,
|
||
Target: g.ID,
|
||
Module: model.WLogModuleGroup,
|
||
Remark: fmt.Sprintf(`“工单编号 %d” %s 理由：%s`, g.ID, s.StateDescr(grp.Business, 0, grp.State), grp.Reason),
|
||
Note: grp.Reason,
|
||
}
|
||
s.writeAuditLog(l)
|
||
|
||
// write challenge log
|
||
for _, c := range tinyChalls {
|
||
l := &model.WLog{
|
||
AdminID: grp.AdminID,
|
||
Admin: grp.AdminName,
|
||
Oid: g.Oid,
|
||
Business: g.Business,
|
||
Target: c.Cid,
|
||
Module: model.WLogModuleChallenge,
|
||
Remark: fmt.Sprintf(`“工单详情编号 %d” %s 理由：%s`, c.Cid, s.StateDescr(grp.Business, 0, grp.State), grp.Reason),
|
||
Note: grp.Reason,
|
||
}
|
||
s.writeAuditLog(l)
|
||
}
|
||
}
|
||
|
||
callback := func() {
|
||
metas := s.dao.AllMetas(context.Background())
|
||
meta, ok := metas[grp.Business]
|
||
if !ok || meta.ItemType != "group" {
|
||
return
|
||
}
|
||
|
||
// handle callback
|
||
cb, ok := s.callbackCache[grp.Business]
|
||
if !ok || cb == nil {
|
||
return
|
||
}
|
||
|
||
mids := make([]int64, 0, len(tinyChalls))
|
||
for _, c := range tinyChalls {
|
||
mids = append(mids, c.Mid)
|
||
}
|
||
|
||
// origin callback
|
||
if cb.URL != "" && cb.State == model.CallbackEnable {
|
||
payload := &model.Payload{
|
||
Verb: model.GroupSetResult,
|
||
Actor: model.Actor{
|
||
AdminID: grp.AdminID,
|
||
},
|
||
CTime: xtime.Time(time.Now().Unix()),
|
||
Object: grp,
|
||
Target: g,
|
||
Influence: map[string]interface{}{
|
||
"mids": mids,
|
||
},
|
||
}
|
||
if err := s.SendCallbackRetry(context.Background(), cb, payload); err != nil {
|
||
log.Error("Failed to s.SendCallbackRetry(%+v, %+v): %v", cb, payload, err)
|
||
// continue
|
||
}
|
||
}
|
||
}
|
||
|
||
extra := func() {
|
||
// extra condition
|
||
switch grp.Business {
|
||
case model.ArchiveComplain:
|
||
s.notifyUsers(grp.Business, grp.Oid, grp.AdminID, tinyChalls, grp.IsMessage)
|
||
default:
|
||
}
|
||
}
|
||
|
||
logging()
|
||
callback()
|
||
extra()
|
||
}
|
||
|
||
func (s *Service) afterBatchSetGrpResult(bgrp *param.BatchGroupResParam, groups map[int64]*model.Group, tinyChalls map[int64]*model.TinyChall) {
|
||
// record log
|
||
logging := func() {
|
||
for _, g := range groups {
|
||
l := &model.WLog{
|
||
AdminID: bgrp.AdminID,
|
||
Admin: bgrp.AdminName,
|
||
Oid: g.Oid,
|
||
Business: g.Business,
|
||
Target: g.ID,
|
||
Module: model.WLogModuleGroup,
|
||
Remark: fmt.Sprintf(`“工单编号 %d” %s 理由：%s`, g.ID, s.StateDescr(bgrp.Business, 0, bgrp.State), bgrp.Reason),
|
||
Note: bgrp.Reason,
|
||
}
|
||
s.writeAuditLog(l)
|
||
}
|
||
for _, c := range tinyChalls {
|
||
g, ok := groups[c.Gid]
|
||
if !ok {
|
||
log.Warn("Failed to retrive group by gid %d", c.Gid)
|
||
continue
|
||
}
|
||
|
||
l := &model.WLog{
|
||
AdminID: bgrp.AdminID,
|
||
Admin: bgrp.AdminName,
|
||
Oid: g.Oid,
|
||
Business: g.Business,
|
||
Target: c.Cid,
|
||
Module: model.WLogModuleChallenge,
|
||
Remark: fmt.Sprintf(`“工单详情编号 %d” 状态从 %s 修改为 %s 理由：%s`, c.Cid, s.StateDescr(bgrp.Business, 0, c.State), s.StateDescr(bgrp.Business, 0, bgrp.State), bgrp.Reason),
|
||
Note: bgrp.Reason,
|
||
}
|
||
s.writeAuditLog(l)
|
||
}
|
||
}
|
||
|
||
// origin callback
|
||
callback := func() {
|
||
metas := s.dao.AllMetas(context.Background())
|
||
meta, ok := metas[bgrp.Business]
|
||
if !ok || meta.ItemType != "group" {
|
||
return
|
||
}
|
||
cb, ok := s.callbackCache[bgrp.Business]
|
||
if !ok || cb == nil {
|
||
return
|
||
}
|
||
|
||
toids := make([]int64, 0, len(groups))
|
||
for _, g := range groups {
|
||
toids = append(toids, g.Oid)
|
||
}
|
||
bgrp.Oids = toids
|
||
|
||
gmids := make(map[int64][]int64, len(groups))
|
||
for _, c := range tinyChalls {
|
||
if _, ok := gmids[c.Gid]; !ok {
|
||
gmids[c.Gid] = make([]int64, 0)
|
||
}
|
||
gmids[c.Gid] = append(gmids[c.Gid], c.Mid)
|
||
}
|
||
|
||
if cb.URL != "" && cb.State == model.CallbackEnable {
|
||
for _, g := range groups {
|
||
payload := &model.Payload{
|
||
Verb: model.BatchGroupSetResult,
|
||
Actor: model.Actor{
|
||
AdminID: bgrp.AdminID,
|
||
},
|
||
CTime: xtime.Time(time.Now().Unix()),
|
||
Object: bgrp,
|
||
Target: g,
|
||
Influence: map[string]interface{}{
|
||
"mids": gmids[g.ID],
|
||
},
|
||
}
|
||
if err := s.SendCallbackRetry(context.Background(), cb, payload); err != nil {
|
||
log.Error("Failed to s.SendCallbackRetry(%+v, %+v): %v", cb, payload, err)
|
||
// continue
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// extra condition
|
||
extra := func() {
|
||
switch bgrp.Business {
|
||
case model.ArchiveComplain:
|
||
oidToChalls := make(map[int64]map[int64]*model.TinyChall, len(groups))
|
||
for _, c := range tinyChalls {
|
||
g, ok := groups[c.Gid]
|
||
if !ok {
|
||
continue
|
||
}
|
||
if _, ok := oidToChalls[g.Oid]; !ok {
|
||
oidToChalls[g.Oid] = make(map[int64]*model.TinyChall)
|
||
}
|
||
oidToChalls[g.Oid][c.Cid] = c
|
||
}
|
||
for oid, cs := range oidToChalls {
|
||
s.notifyUsers(bgrp.Business, oid, bgrp.AdminID, cs, bgrp.IsMessage)
|
||
}
|
||
default:
|
||
}
|
||
}
|
||
|
||
logging()
|
||
callback()
|
||
extra()
|
||
}
|
||
|
||
func (s *Service) afterSetChallResult(crp *param.ChallResParam, c *model.Chall) {
|
||
logging := func() {
|
||
// write challenge log
|
||
l := &model.WLog{
|
||
AdminID: crp.AdminID,
|
||
Admin: crp.AdminName,
|
||
Oid: c.Oid,
|
||
Business: c.Business,
|
||
Target: c.Cid,
|
||
Module: model.WLogModuleChallenge,
|
||
Remark: fmt.Sprintf(`“工单详情编号 %d” 处理状态从 %s 修改为 %s 理由：%s`, c.Cid, s.StateDescr(c.Business, 0, c.State), s.StateDescr(c.Business, 0, crp.State), crp.Reason),
|
||
Note: crp.Reason,
|
||
}
|
||
s.writeAuditLog(l)
|
||
}
|
||
|
||
callback := func() {
|
||
metas := s.dao.AllMetas(context.Background())
|
||
meta, ok := metas[c.Business]
|
||
if !ok || meta.ItemType != "challenge" {
|
||
log.Warn("item type not exist or is not challenge, meta(%+v)", meta)
|
||
return
|
||
}
|
||
|
||
// handle callback
|
||
cb, ok := s.callbackCache[c.Business]
|
||
if !ok || cb == nil {
|
||
log.Error("can not find callback func, business(%d)", c.Business)
|
||
return
|
||
}
|
||
|
||
mids := []int64{c.Mid}
|
||
if cb.URL != "" && cb.State == model.CallbackEnable {
|
||
payload := &model.Payload{
|
||
Verb: model.ChallSetResult,
|
||
Actor: model.Actor{
|
||
AdminID: crp.AdminID,
|
||
},
|
||
CTime: xtime.Time(time.Now().Unix()),
|
||
Object: crp,
|
||
Target: c,
|
||
Influence: map[string]interface{}{
|
||
"mids": mids,
|
||
},
|
||
}
|
||
if err := s.SendCallbackRetry(context.Background(), cb, payload); err != nil {
|
||
log.Error("Failed to s.SendCallbackRetry(%+v, %+v): %v", cb, payload, err)
|
||
// continue
|
||
}
|
||
}
|
||
}
|
||
|
||
extra := func() {
|
||
// extra condition
|
||
}
|
||
|
||
logging()
|
||
callback()
|
||
extra()
|
||
}
|
||
|
||
func (s *Service) afterBatchSetChallResult(bcrp *param.BatchChallResParam, challs map[int64]*model.Chall) {
|
||
// Record Log
|
||
logging := func() {
|
||
for _, c := range challs {
|
||
l := &model.WLog{
|
||
AdminID: bcrp.AdminID,
|
||
Admin: bcrp.AdminName,
|
||
Oid: c.Oid,
|
||
Business: c.Business,
|
||
Target: c.Cid,
|
||
Module: model.WLogModuleChallenge,
|
||
Remark: fmt.Sprintf(`“工单详情编号 %d” 状态从 %s 修改为 %s 理由：%s`, c.Cid, s.StateDescr(c.Business, 0, c.State), s.StateDescr(c.Business, 0, bcrp.State), bcrp.Reason),
|
||
Note: bcrp.Reason,
|
||
}
|
||
s.writeAuditLog(l)
|
||
}
|
||
}
|
||
|
||
// origin callback
|
||
callback := func() {
|
||
metas := s.dao.AllMetas(context.Background())
|
||
for _, c := range challs {
|
||
meta, ok := metas[c.Business]
|
||
if !ok || meta.ItemType != "challenge" {
|
||
return
|
||
}
|
||
|
||
cb, ok := s.callbackCache[c.Business]
|
||
if !ok || cb == nil {
|
||
return
|
||
}
|
||
|
||
mids := []int64{c.Mid}
|
||
// origin callback
|
||
if cb.URL != "" && cb.State == model.CallbackEnable {
|
||
payload := &model.Payload{
|
||
Verb: model.BatchChallSetResult,
|
||
Actor: model.Actor{
|
||
AdminID: bcrp.AdminID,
|
||
},
|
||
CTime: xtime.Time(time.Now().Unix()),
|
||
Object: bcrp,
|
||
Target: c,
|
||
Influence: map[string]interface{}{
|
||
"mids": mids,
|
||
},
|
||
}
|
||
if err := s.SendCallbackRetry(context.Background(), cb, payload); err != nil {
|
||
log.Error("Failed to s.SendCallbackRetry(%+v, %+v): %v", cb, payload, err)
|
||
// continue
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
extra := func() {
|
||
// extra condition
|
||
}
|
||
logging()
|
||
callback()
|
||
extra()
|
||
}
|
||
|
||
func (s *Service) afterSetGroupRole(grsp *param.GroupRoleSetParam, groups map[int64]*model.Group) {
|
||
// Record Log
|
||
logging := func() {
|
||
logs, err := s.LastLogStat(context.Background(), grsp.GID, []int{model.WLogModuleRoleShift}, []string{"int_1", "ctime", "int_2", "uid"})
|
||
if err != nil {
|
||
log.Error("s.LastLogStat() failed error:%v", err)
|
||
return
|
||
}
|
||
for _, g := range groups {
|
||
var (
|
||
preTag *model.TagMeta
|
||
newTag *model.TagMeta
|
||
err error
|
||
)
|
||
if preTag, err = s.tag(g.Business, g.Tid); err != nil {
|
||
log.Warn("s.tag(%d,%d) error(%v)", g.Business, g.Tid, err)
|
||
err = nil
|
||
preTag.Bid = g.Business
|
||
preTag.Tid = g.Tid
|
||
preTag.RID = g.Rid
|
||
}
|
||
if newTag, err = s.tag(g.Business, grsp.TID); err != nil {
|
||
log.Warn("s.tag(%d,%d) error(%v)", g.Business, g.Tid, err)
|
||
err = nil
|
||
newTag.Bid = g.Business
|
||
newTag.Tid = g.Tid
|
||
}
|
||
|
||
l := &model.WLog{
|
||
AdminID: grsp.AdminID,
|
||
Admin: grsp.AdminName,
|
||
Oid: g.Oid,
|
||
Business: g.Business,
|
||
Target: g.ID,
|
||
Module: model.WLogModuleRoleShift,
|
||
Remark: fmt.Sprintf(`“工单编号 %d” 业务角色流转从 %d:%s 到 %d:%s, 管理 tag 从 %d:%s 变更到 %d:%s, 备注: %s`,
|
||
g.ID, g.Rid, s.RidDesc(g.Business, g.Rid), grsp.RID, s.RidDesc(g.Business, grsp.RID), g.Tid, preTag.Name, grsp.TID, newTag.Name, grsp.Note),
|
||
Note: grsp.Note,
|
||
OpType: strconv.Itoa(int(model.RoleShift)),
|
||
PreRid: strconv.Itoa(int(preTag.RID)),
|
||
}
|
||
if roleLog, ok := logs[g.ID]; !ok {
|
||
l.TimeConsume = int64(time.Since(g.LastTime.Time()) / time.Second)
|
||
} else {
|
||
lastRoleTime, _ := time.ParseInLocation("2006-01-02 15:04:05", roleLog.CTime, time.Local)
|
||
if lastRoleTime.After(g.LastTime.Time()) {
|
||
l.TimeConsume = int64(time.Since(lastRoleTime) / time.Second)
|
||
} else {
|
||
l.TimeConsume = int64(time.Since(g.LastTime.Time()) / time.Second)
|
||
}
|
||
}
|
||
s.writeAuditLog(l)
|
||
}
|
||
}
|
||
logging()
|
||
}
|
||
|
||
// set state v3
|
||
func (s *Service) afterSetGroupState(gssp *param.GroupStateSetParam, groups map[int64]*model.Group, tinyChalls map[int64]*model.TinyChall) {
|
||
// record log
|
||
logging := func() {
|
||
logs, err := s.LastLogStat(context.Background(), gssp.ID, []int{model.WLogModuleRoleShift}, []string{"int_1", "ctime", "int_2", "uid"})
|
||
if err != nil {
|
||
log.Error("s.LastLogStat() failed error:%v", err)
|
||
return
|
||
}
|
||
for _, g := range groups {
|
||
l := &model.WLog{
|
||
AdminID: gssp.AdminID,
|
||
Admin: gssp.AdminName,
|
||
Oid: g.Oid,
|
||
Business: g.Business,
|
||
Target: g.ID,
|
||
Module: model.WLogModuleGroup,
|
||
Remark: fmt.Sprintf(`“工单编号 %d” %s 理由：%s`, g.ID, s.StateDescr(g.Business, 0, gssp.State), gssp.Reason),
|
||
Note: gssp.Reason,
|
||
OpType: strconv.Itoa(int(gssp.State)),
|
||
PreRid: strconv.Itoa(int(gssp.Rid)),
|
||
Param: gssp,
|
||
}
|
||
if roleLog, ok := logs[g.ID]; !ok {
|
||
l.TimeConsume = int64(time.Since(g.LastTime.Time()) / time.Second)
|
||
} else {
|
||
lastRoleTime, _ := time.ParseInLocation("2006-01-02 15:04:05", roleLog.CTime, time.Local)
|
||
if lastRoleTime.After(g.LastTime.Time()) {
|
||
l.TimeConsume = int64(time.Since(lastRoleTime) / time.Second)
|
||
} else {
|
||
l.TimeConsume = int64(time.Since(g.LastTime.Time()) / time.Second)
|
||
}
|
||
}
|
||
if g.BusinessObject != nil {
|
||
l.Mid = g.BusinessObject.Mid
|
||
}
|
||
s.writeAuditLog(l)
|
||
}
|
||
for _, c := range tinyChalls {
|
||
g, ok := groups[c.Gid]
|
||
if !ok {
|
||
log.Warn("Failed to retrive group by gid %d", c.Gid)
|
||
continue
|
||
}
|
||
|
||
l := &model.WLog{
|
||
AdminID: gssp.AdminID,
|
||
Admin: gssp.AdminName,
|
||
Oid: g.Oid,
|
||
Business: g.Business,
|
||
Target: c.Cid,
|
||
Module: model.WLogModuleChallenge,
|
||
Remark: fmt.Sprintf(`“工单详情编号 %d” 状态从 %s 修改为 %s 理由：%s`, c.Cid, s.StateDescr(g.Business, 0, c.State), s.StateDescr(g.Business, 0, gssp.State), gssp.Reason),
|
||
Note: gssp.Reason,
|
||
Mid: c.Mid,
|
||
}
|
||
s.writeAuditLog(l)
|
||
}
|
||
}
|
||
|
||
// origin callback
|
||
callback := func() {
|
||
cb, ok := s.callbackCache[gssp.Business]
|
||
if !ok || cb == nil {
|
||
return
|
||
}
|
||
|
||
gmids := make(map[int64][]int64, len(groups))
|
||
for _, c := range tinyChalls {
|
||
if _, ok := gmids[c.Gid]; !ok {
|
||
gmids[c.Gid] = make([]int64, 0)
|
||
}
|
||
gmids[c.Gid] = append(gmids[c.Gid], c.Mid)
|
||
}
|
||
|
||
if cb.URL != "" && cb.State == model.CallbackEnable {
|
||
//common
|
||
payload := &model.Payload{
|
||
Bid: int(gssp.Business),
|
||
Verb: model.GroupSetState,
|
||
Actor: model.Actor{
|
||
AdminID: gssp.AdminID,
|
||
AdminName: gssp.AdminName,
|
||
},
|
||
CTime: xtime.Time(time.Now().Unix()),
|
||
Object: gssp,
|
||
}
|
||
|
||
// influence
|
||
// 长短评
|
||
if gssp.Business == model.ReviewShortComplain || gssp.Business == model.ReviewLongComplain {
|
||
var reportMids = make([]int64, len(tinyChalls))
|
||
for _, tc := range tinyChalls {
|
||
reportMids = append(reportMids, tc.Mid)
|
||
}
|
||
payload.Influence = map[string]interface{}{
|
||
"mids": reportMids,
|
||
}
|
||
}
|
||
|
||
// target
|
||
for _, g := range groups {
|
||
payload.Targets = append(payload.Targets, g)
|
||
}
|
||
//todo: extra
|
||
|
||
if err := s.SendCallbackRetry(context.Background(), cb, payload); err != nil {
|
||
log.Error("Failed to s.SendCallbackRetry(%+v, %+v): %v", cb, payload, err)
|
||
// continue
|
||
}
|
||
}
|
||
}
|
||
|
||
// notify user
|
||
notify := func() {
|
||
s.notifyUsersV4(gssp, groups, tinyChalls)
|
||
}
|
||
|
||
// 扣节操
|
||
decreaseMoral := func() {
|
||
if gssp.DecreaseMoral == 0 {
|
||
return
|
||
}
|
||
var (
|
||
gids []int64
|
||
mids []int64
|
||
)
|
||
|
||
for _, g := range groups {
|
||
gids = append(gids, g.ID)
|
||
}
|
||
// 被举报人 mid
|
||
var (
|
||
bus map[int64]*model.Business
|
||
err error
|
||
)
|
||
if bus, err = s.dao.BusObjectByGids(context.Background(), gids); err != nil {
|
||
log.Error("s.dao.BusObjectByGids(%v) error(%v)", gids, err)
|
||
return
|
||
}
|
||
for _, b := range bus {
|
||
mids = append(mids, b.Mid)
|
||
}
|
||
|
||
if err := s.dao.AddMoral(context.Background(), mids, gssp); err != nil {
|
||
log.Error("s.dao.AddMoral(%v,%d) error(%v)", mids, gssp.DecreaseMoral, err)
|
||
return
|
||
}
|
||
l := &model.WLog{
|
||
AdminID: gssp.AdminID,
|
||
Admin: gssp.AdminName,
|
||
Module: model.WLogModuleAddMoral,
|
||
Mids: mids,
|
||
Param: gssp,
|
||
}
|
||
s.writeAuditLog(l)
|
||
}
|
||
|
||
// 封禁账号
|
||
block := func() {
|
||
if gssp.BlockDay == 0 {
|
||
return
|
||
}
|
||
var (
|
||
gids []int64
|
||
mids []int64
|
||
)
|
||
for _, g := range groups {
|
||
gids = append(gids, g.ID)
|
||
}
|
||
// 被举报人 mid
|
||
var (
|
||
bus map[int64]*model.Business
|
||
err error
|
||
)
|
||
if bus, err = s.dao.BusObjectByGids(context.Background(), gids); err != nil {
|
||
log.Error("s.dao.BusObjectByGids(%v) error(%v)", gids, err)
|
||
return
|
||
}
|
||
for _, b := range bus {
|
||
mids = append(mids, b.Mid)
|
||
}
|
||
|
||
if err := s.dao.AddBlock(context.Background(), mids, gssp); err != nil {
|
||
log.Error("s.dao.AddBlock(%d,%v) error(%v)", mids, gssp, err)
|
||
return
|
||
}
|
||
|
||
if err := s.dao.AddCreditBlockInfo(context.Background(), bus, gssp); err != nil {
|
||
log.Error("s.dao.AddCreditBlockInfo(%d,%v) error(%v)", mids, gssp, err)
|
||
return
|
||
}
|
||
l := &model.WLog{
|
||
AdminID: gssp.AdminID,
|
||
Admin: gssp.AdminName,
|
||
Module: model.WLogModuleBlock,
|
||
Mids: mids,
|
||
Param: gssp,
|
||
}
|
||
s.writeAuditLog(l)
|
||
}
|
||
|
||
logging()
|
||
callback()
|
||
notify()
|
||
decreaseMoral()
|
||
block()
|
||
}
|
||
|
||
// only set group state
|
||
func (s *Service) afterSimpleSetState(gspr *param.GroupStatePublicReferee, groups map[int64]*model.Group) {
|
||
// record log
|
||
logging := func() {
|
||
for _, g := range groups {
|
||
l := &model.WLog{
|
||
AdminID: gspr.AdminID,
|
||
Admin: gspr.AdminName,
|
||
Oid: g.Oid,
|
||
Business: g.Business,
|
||
Target: g.ID,
|
||
Module: model.WLogModulePublicReferee,
|
||
Remark: fmt.Sprintf(`“工单编号 %d” %s 理由：%s`, g.ID, s.StateDescr(g.Business, 0, gspr.State), ""),
|
||
OpType: strconv.Itoa(int(gspr.State)),
|
||
}
|
||
s.writeAuditLog(l)
|
||
}
|
||
}
|
||
|
||
// callback
|
||
callback := func() {
|
||
cb, ok := s.callbackCache[gspr.Business]
|
||
if !ok || cb == nil {
|
||
return
|
||
}
|
||
gssp := ¶m.GroupStateSetParam{
|
||
ID: gspr.ID,
|
||
Business: gspr.Business,
|
||
AdminID: gspr.AdminID,
|
||
AdminName: gspr.AdminName,
|
||
State: gspr.State,
|
||
}
|
||
if cb.URL != "" && cb.State == model.CallbackEnable {
|
||
//common
|
||
payload := &model.Payload{
|
||
Bid: int(gssp.Business),
|
||
Verb: model.GroupSetPublicReferee,
|
||
Actor: model.Actor{
|
||
AdminID: gssp.AdminID,
|
||
AdminName: gssp.AdminName,
|
||
},
|
||
CTime: xtime.Time(time.Now().Unix()),
|
||
Object: gssp,
|
||
}
|
||
// target
|
||
for _, g := range groups {
|
||
payload.Targets = append(payload.Targets, g)
|
||
}
|
||
|
||
if err := s.SendCallbackRetry(context.Background(), cb, payload); err != nil {
|
||
log.Error("Failed to s.SendCallbackRetry(%+v, %+v): %v", cb, payload, err)
|
||
// continue
|
||
}
|
||
}
|
||
}
|
||
|
||
logging()
|
||
callback()
|
||
}
|
||
|
||
func (s *Service) afterSetBusinessState(challs []*model.Chall) {
|
||
// todo: after set business state
|
||
logging := func() {
|
||
for _, c := range challs {
|
||
l := &model.WLog{
|
||
AdminID: c.AssigneeAdminID,
|
||
Admin: c.AssigneeAdminName,
|
||
Oid: c.Oid,
|
||
Business: c.Business,
|
||
Target: c.Cid,
|
||
Module: model.WLogModuleReply,
|
||
Mid: c.Mid,
|
||
TypeID: c.TypeID,
|
||
}
|
||
s.writeAuditLog(l)
|
||
}
|
||
}
|
||
logging()
|
||
}
|
||
|
||
func (s *Service) afterAddReply(ep *param.EventParam, c *model.Chall) {
|
||
logging := func() {
|
||
l := &model.WLog{
|
||
AdminID: ep.AdminID,
|
||
Admin: ep.AdminName,
|
||
Oid: c.Oid,
|
||
Business: c.Business,
|
||
Target: c.Cid,
|
||
Module: model.FeedBackTypeReply,
|
||
Mid: c.Mid,
|
||
Remark: ep.Content,
|
||
Note: strconv.Itoa(int(ep.Event)),
|
||
Meta: map[string]interface{}{
|
||
"ep": ep,
|
||
"challenge": c,
|
||
},
|
||
}
|
||
s.writeReplyLog(l)
|
||
}
|
||
logging()
|
||
}
|
||
|
||
func (s *Service) afterAddMultiReply(bep *param.BatchEventParam, cs map[int64]*model.Chall) {
|
||
loggin := func() {
|
||
for _, cid := range bep.Cids {
|
||
var (
|
||
c *model.Chall
|
||
ok bool
|
||
)
|
||
if c, ok = cs[cid]; !ok {
|
||
continue
|
||
}
|
||
l := &model.WLog{
|
||
AdminID: bep.AdminID,
|
||
Admin: bep.AdminName,
|
||
Oid: c.Oid,
|
||
Business: c.Business,
|
||
Target: c.Cid,
|
||
Module: model.FeedBackTypeReply,
|
||
Mid: c.Mid,
|
||
Remark: bep.Content,
|
||
Note: strconv.Itoa(int(bep.Event)),
|
||
Meta: map[string]interface{}{
|
||
"bep": bep,
|
||
"challenge": cs,
|
||
},
|
||
}
|
||
s.writeReplyLog(l)
|
||
}
|
||
}
|
||
|
||
loggin()
|
||
}
|
||
|
||
func (s *Service) notifyUsers(business int8, oid int64, adminid int64, challs map[int64]*model.TinyChall, isDisposeMsg bool) (err error) {
|
||
var makeDealMsgParam = model.DealArcComplainMsg
|
||
var makeReceivedMsgParam = model.ReceivedArcComplainMsg
|
||
|
||
mids := make([]int64, 0, len(challs))
|
||
for _, c := range challs {
|
||
mids = append(mids, int64(c.Mid))
|
||
}
|
||
|
||
if business == int8(model.ArchiveComplain) {
|
||
// if challenge ctime < 10min, report appeal received
|
||
var rChall = make([]*model.TinyChall, 0)
|
||
var rMids = make([]int64, 0)
|
||
for _, c := range challs {
|
||
if time.Since(c.CTime.Time()) < time.Minute*10 {
|
||
//todo: rmids send message archive complain received
|
||
rChall = append(rChall, c)
|
||
rMids = append(rMids, c.Mid)
|
||
}
|
||
}
|
||
|
||
if len(rChall) > 0 {
|
||
rmp := makeReceivedMsgParam(oid, rMids)
|
||
if err = s.dao.SendMessage(context.Background(), rmp); err != nil {
|
||
log.Error("Failed to s.dao.SendMessage(%v, %v, %+v): %v", oid, mids, rmp, err)
|
||
err = nil
|
||
}
|
||
log.Info("send archive complain received message business(%d) oid(%d) mids(%v) mc(%s) message(%+v)", business, oid, mids, rmp.MC, rmp)
|
||
|
||
// report archive complain received msg
|
||
for _, tc := range rChall {
|
||
report.Manager(&report.ManagerInfo{
|
||
Uname: "",
|
||
UID: 0,
|
||
Business: 11,
|
||
Type: 2,
|
||
Oid: oid,
|
||
Action: "notify_users_received",
|
||
Ctime: time.Now(),
|
||
Index: []interface{}{tc.Cid, tc.Gid, tc.Mid},
|
||
Content: map[string]interface{}{
|
||
"mid": tc.Mid,
|
||
"message": rmp,
|
||
},
|
||
})
|
||
}
|
||
}
|
||
}
|
||
if !isDisposeMsg {
|
||
return
|
||
}
|
||
time.Sleep(500 * time.Millisecond)
|
||
mdmp := makeDealMsgParam(oid, mids)
|
||
if err = s.dao.SendMessage(context.Background(), mdmp); err != nil {
|
||
log.Error("Failed to s.dao.SendMessage(%v, %v, %+v): %v", oid, mids, mdmp, err)
|
||
return
|
||
}
|
||
|
||
// group dispose report
|
||
report.Manager(&report.ManagerInfo{
|
||
Uname: "",
|
||
UID: adminid,
|
||
Business: 11,
|
||
Type: 3,
|
||
Oid: oid,
|
||
Action: "notify_users_dispose",
|
||
Ctime: time.Now(),
|
||
Index: []interface{}{business},
|
||
Content: map[string]interface{}{
|
||
"mid": mids,
|
||
"message": mdmp,
|
||
},
|
||
})
|
||
|
||
log.Info("send message business(%d) oid(%d) mids(%v) mc(%s) message(%+v)", business, oid, mids, mdmp.MC, mdmp)
|
||
return
|
||
}
|
||
|
||
func (s *Service) notifyUsersV4(gssp *param.GroupStateSetParam, groups map[int64]*model.Group, tinyChalls map[int64]*model.TinyChall) (err error) {
|
||
// 稿件投诉补发已收到消息
|
||
if gssp.Business == model.ArchiveComplain {
|
||
for _, g := range groups {
|
||
// if challenge ctime < 10min, report appeal received
|
||
var rMids = make([]int64, 0)
|
||
for _, c := range tinyChalls {
|
||
if time.Since(c.CTime.Time()) < time.Minute*10 && c.Gid == g.ID {
|
||
//todo: rmids send message archive complain received
|
||
rMids = append(rMids, c.Mid)
|
||
}
|
||
}
|
||
if len(rMids) > 0 {
|
||
rmp := ¶m.MessageParam{
|
||
Type: "json",
|
||
Source: 1,
|
||
DataType: 4,
|
||
MC: model.ArcComplainRevMC,
|
||
Title: "您的投诉已收到",
|
||
Context: fmt.Sprintf("您对稿件（av%d）的举报我们已经收到。感谢您对 bilibili 社区秩序的维护，哔哩哔哩 (゜-゜)つロ 干杯~", g.Oid),
|
||
MidList: rMids,
|
||
}
|
||
if err = s.dao.SendMessage(context.Background(), rmp); err != nil {
|
||
log.Error("Failed to s.dao.SendMessage(%+v) mid(%v): %v", rmp, rMids, err)
|
||
err = nil
|
||
}
|
||
log.Info("send archive complain received message gid(%d) oid(%d) mids(%v) message(%+v)", g.ID, g.Oid, rMids, rmp)
|
||
// report archive complain received msg
|
||
report.Manager(&report.ManagerInfo{
|
||
Uname: "",
|
||
UID: 0,
|
||
Business: 11,
|
||
Type: model.FeedBackTypeNotifyUserReceived,
|
||
Oid: g.Oid,
|
||
Action: "notify_users_received_v4",
|
||
Ctime: time.Now(),
|
||
Index: []interface{}{g.ID},
|
||
Content: map[string]interface{}{
|
||
"message": rmp,
|
||
},
|
||
})
|
||
}
|
||
}
|
||
}
|
||
time.Sleep(500 * time.Millisecond)
|
||
|
||
// 通知举报人
|
||
if gssp.IsMessage {
|
||
mps := make(map[int64]*param.MessageParam) // map[oid]*mp or map[eid]*mp
|
||
// all mids need to report
|
||
cmids := make(map[int64][]int64) //map[gid][]mids
|
||
for _, c := range tinyChalls {
|
||
if _, ok := cmids[c.Gid]; !ok {
|
||
cmids[c.Gid] = make([]int64, 0)
|
||
}
|
||
cmids[c.Gid] = append(cmids[c.Gid], c.Mid)
|
||
}
|
||
|
||
switch gssp.Business {
|
||
case model.ArchiveComplain:
|
||
for _, g := range groups {
|
||
reportMids, ok := cmids[g.ID]
|
||
if !ok {
|
||
log.Warn("report mid not found gid(%d)", g.ID)
|
||
continue
|
||
}
|
||
mp := ¶m.MessageParam{
|
||
Type: "json",
|
||
Source: 1,
|
||
DataType: 4,
|
||
MC: model.ArcComplainDealMC,
|
||
Title: "您的投诉已被受理",
|
||
Context: fmt.Sprintf("您对稿件（av%d）的投诉已被受理。感谢您对 bilibili 社区秩序的维护，哔哩哔哩 (゜-゜)つロ 干杯~ ", g.Oid),
|
||
MidList: reportMids,
|
||
}
|
||
mps[g.ID] = mp
|
||
}
|
||
case model.ChannelComplain:
|
||
for _, g := range groups {
|
||
reportMids, ok := cmids[g.ID]
|
||
if !ok {
|
||
log.Warn("report mid not found gid(%d)", g.ID)
|
||
continue
|
||
}
|
||
mp := ¶m.MessageParam{
|
||
Type: "json",
|
||
Source: 1,
|
||
DataType: 4,
|
||
MC: model.WkfNotifyMC,
|
||
Title: "你的举报已成功处理",
|
||
Context: fmt.Sprintf(`您在稿件【#{av%d}{"https://www.bilibili.com/video/av%d"}】举报的频道【%s】已处理，感谢反馈，点击进去查看`,
|
||
g.Oid, g.Oid, g.BusinessObject.Title),
|
||
MidList: reportMids,
|
||
}
|
||
mps[g.ID] = mp
|
||
}
|
||
case model.CommentComplain: // 评论举报
|
||
var blockStr, isDel string
|
||
if gssp.BlockDay == -1 {
|
||
blockStr = "该用户已被永久封禁。"
|
||
} else if gssp.BlockDay > 0 {
|
||
blockStr = fmt.Sprintf("并被封禁%d天。", gssp.BlockDay)
|
||
}
|
||
if gssp.DisposeMode == 1 {
|
||
isDel = "已被移除"
|
||
} else {
|
||
isDel = "已被处罚"
|
||
}
|
||
tMeta, _ := s.tag(gssp.Business, gssp.Tid)
|
||
tName := tMeta.Name // 举报理由
|
||
for _, g := range groups {
|
||
if g.Fid == model.ReplyFidManga {
|
||
continue
|
||
}
|
||
var extMap map[string]interface{}
|
||
reportMids, ok := cmids[g.ID]
|
||
if !ok {
|
||
log.Warn("report mid not found gid(%d)", g.ID)
|
||
continue
|
||
}
|
||
json.Unmarshal([]byte(g.BusinessObject.Extra), &extMap)
|
||
extTitle, _ := extMap["title"].(string)
|
||
extTitle = subString(extTitle, 0, 40)
|
||
extLink, _ := extMap["link"].(string)
|
||
content := fmt.Sprintf(`您好，您在#{%s}{%s}下举报的评论『%s』%s，%s 理由：%s。`+model.NotifyComRulesReport,
|
||
extTitle, extLink, pretreat(g.BusinessObject.Title), isDel, blockStr, tName)
|
||
mp := ¶m.MessageParam{
|
||
Type: "json",
|
||
Source: 1,
|
||
DataType: 4,
|
||
MC: model.WkfNotifyMC,
|
||
Title: "举报处理结果通知",
|
||
Context: content,
|
||
MidList: reportMids,
|
||
}
|
||
mps[g.ID] = mp
|
||
}
|
||
}
|
||
for gid, mp := range mps {
|
||
if err = s.dao.SendMessage(context.Background(), mp); err != nil {
|
||
log.Error("Failed to s.dao.SendMessage(%+v) mids(%v): %v", mp, err)
|
||
continue
|
||
}
|
||
// group dispose report
|
||
report.Manager(&report.ManagerInfo{
|
||
Uname: gssp.AdminName,
|
||
UID: gssp.AdminID,
|
||
Business: 11,
|
||
Type: model.FeedBackTypeNotifyUserDisposed,
|
||
Action: "notify_users_v4_reporters",
|
||
Ctime: time.Now(),
|
||
Index: []interface{}{gssp.Business},
|
||
Content: map[string]interface{}{
|
||
"message": mp,
|
||
},
|
||
})
|
||
log.Info("notifyUsersV4 success send to reporters message(%+v) gid(%d)", mp, gid)
|
||
}
|
||
}
|
||
|
||
// 通知被举报人(up主)
|
||
if gssp.IsMessageUper {
|
||
mps := make(map[int64]*param.MessageParam) // map[oid]*mp or map[eid]*mp
|
||
switch gssp.Business {
|
||
case model.CommentComplain: //评论举报
|
||
var (
|
||
blockStr string
|
||
disposeStr string
|
||
)
|
||
if gssp.BlockDay == -1 {
|
||
blockStr = "本帐号已被永久封禁。"
|
||
} else if gssp.BlockDay > 0 {
|
||
blockStr = fmt.Sprintf("并被封禁%d天。", gssp.BlockDay)
|
||
}
|
||
if gssp.DisposeMode == 1 {
|
||
disposeStr = "已被举报并移除"
|
||
} else {
|
||
disposeStr = "已被举报并处罚"
|
||
}
|
||
tMeta, _ := s.tag(gssp.Business, gssp.Tid)
|
||
tName := tMeta.Name // 举报理由
|
||
for _, g := range groups {
|
||
if g.Fid == model.ReplyFidManga {
|
||
continue
|
||
}
|
||
var extMap map[string]interface{}
|
||
json.Unmarshal([]byte(g.BusinessObject.Extra), &extMap)
|
||
extTitle, _ := extMap["title"].(string)
|
||
extTitle = subString(extTitle, 0, 40)
|
||
extLink, _ := extMap["link"].(string)
|
||
content := fmt.Sprintf(`您好，您在#{%s}{%s}下发布的评论『%s』%s，%s 理由：%s。`, extTitle, extLink, pretreat(g.BusinessObject.Title), disposeStr, blockStr, tName)
|
||
content = suffixContent(content, gssp)
|
||
mp := ¶m.MessageParam{
|
||
Type: "json",
|
||
Source: 1,
|
||
DataType: 4,
|
||
MC: model.WkfNotifyMC,
|
||
Title: "评论违规处理通知",
|
||
Context: content,
|
||
MidList: []int64{g.BusinessObject.Mid},
|
||
}
|
||
mps[g.ID] = mp
|
||
}
|
||
}
|
||
for gid, mp := range mps {
|
||
if err = s.dao.SendMessage(context.Background(), mp); err != nil {
|
||
log.Error("Failed to s.dao.SendMessage(%+v) gid(%d): %v", mp, gid, err)
|
||
continue
|
||
}
|
||
// group dispose report
|
||
report.Manager(&report.ManagerInfo{
|
||
Uname: gssp.AdminName,
|
||
UID: gssp.AdminID,
|
||
Business: 11,
|
||
Type: 3,
|
||
Action: "notify_users_v4_upers",
|
||
Ctime: time.Now(),
|
||
Index: []interface{}{gssp.Business},
|
||
Content: map[string]interface{}{
|
||
"mid": mp.MidList,
|
||
"message": *mp,
|
||
},
|
||
})
|
||
log.Info("notifyUsersV4 success send to uper message(%+v) gid(%d)", mp, gid)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// 站内信评论内容预处理
|
||
func pretreat(str string) string {
|
||
str = subString(str, 0, 40)
|
||
str = filterViolationMsg(str)
|
||
return str
|
||
}
|
||
|
||
// 字符串截断
|
||
func subString(str string, begin, length int) string {
|
||
rs := []rune(str)
|
||
lth := len(rs)
|
||
if begin < 0 {
|
||
begin = 0
|
||
}
|
||
if begin >= lth {
|
||
begin = lth
|
||
}
|
||
end := begin + length
|
||
if end > lth {
|
||
end = lth
|
||
}
|
||
return string(rs[begin:end])
|
||
}
|
||
|
||
// 字符串加*
|
||
func filterViolationMsg(msg string) string {
|
||
s := []rune(msg)
|
||
for i := 0; i < len(s); i++ {
|
||
if i%3 != 0 {
|
||
s[i] = '*'
|
||
}
|
||
}
|
||
return string(s)
|
||
}
|
||
|
||
// 评论站内信后缀(被举报人)
|
||
func suffixContent(content string, gssp *param.GroupStateSetParam) string {
|
||
switch gssp.BlockReason {
|
||
// 剧透, 广告, 抢楼, 刷屏
|
||
case credit.ReasonSpoiler, credit.ReasonGarbageAds, credit.ReasonGrabFloor, credit.ReasonBrushScreen:
|
||
content += model.NotifyComRules
|
||
// 引战, 人身攻击
|
||
case credit.ReasonLeadBattle, credit.ReasonPersonalAttacks:
|
||
content += model.NotifyComProvoke
|
||
default:
|
||
content += model.NofityComProhibited
|
||
}
|
||
return content
|
||
}
|