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.
505 lines
14 KiB
505 lines
14 KiB
package service |
|
|
|
import ( |
|
"context" |
|
"fmt" |
|
"strconv" |
|
"strings" |
|
"time" |
|
|
|
"go-common/app/admin/main/reply/model" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
"go-common/library/queue/databus/report" |
|
"go-common/library/sync/errgroup" |
|
xtime "go-common/library/time" |
|
) |
|
|
|
func forbidResult(ftime int64) string { |
|
if ftime == -1 { |
|
return "永久" |
|
} |
|
return fmt.Sprintf("%d天", ftime) |
|
} |
|
|
|
func (s *Service) report(c context.Context, oid, rpID int64) (report *model.Report, err error) { |
|
if report, err = s.dao.Report(c, oid, rpID); err != nil { |
|
return |
|
} |
|
if report == nil { |
|
err = ecode.ReplyReportNotExist |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) reports(c context.Context, oids, rpIDs []int64) (res map[int64]*model.Report, err error) { |
|
if res, err = s.dao.Reports(c, oids, rpIDs); err != nil { |
|
return |
|
} |
|
return |
|
} |
|
|
|
// ReportSearch return report result from search. |
|
func (s *Service) ReportSearch(c context.Context, sp *model.SearchReportParams, page, pageSize int64) (res *model.SearchReportResult, err error) { |
|
if res, err = s.dao.SearchReport(c, sp, page, pageSize); err != nil { |
|
log.Error("s.dao.SearchReport(%+v,%d,%d) error(%v)", sp, page, pageSize, err) |
|
return |
|
} |
|
filterIds := map[int64]string{} |
|
oids := map[int64]string{} |
|
admins := map[int64]string{} |
|
titles := map[int64]string{} |
|
for _, r := range res.Result { |
|
r.OidStr = strconv.FormatInt(r.Oid, 10) |
|
if strings.Contains(r.Message, "*") { |
|
filterIds[r.ID] = "" |
|
} else if len(r.Attr) > 0 { |
|
for _, attr := range r.Attr { |
|
if attr == 4 { |
|
filterIds[r.ID] = "" |
|
} |
|
} |
|
} |
|
admins[r.AdminID] = "" |
|
if r.ReplyMid == r.ArcMid { |
|
r.IsUp = 1 |
|
} |
|
oids[r.Oid] = "" |
|
if int32(r.Type) == model.SubTypeArchive { |
|
titles[r.Oid] = "" |
|
} |
|
} |
|
s.linkByOids(c, oids, sp.Type) |
|
s.titlesByOids(c, titles) |
|
s.dao.AdminName(c, admins) |
|
s.dao.FilterContents(c, filterIds) |
|
for i, data := range res.Result { |
|
res.Result[i].AdminName = admins[res.Result[i].AdminID] |
|
if content, ok := filterIds[data.ID]; ok && content != "" { |
|
data.Message = content |
|
} |
|
if content, ok := oids[data.Oid]; ok { |
|
data.RedirectURL = fmt.Sprintf("%s#reply%d", content, data.ID) |
|
} |
|
if int32(data.Type) == model.SubTypeArchive && data.Title == "" { |
|
if title := titles[data.Oid]; title != "" { |
|
data.Title = title |
|
} |
|
} |
|
} |
|
|
|
return |
|
} |
|
|
|
// ReportIgnore ignore a report. |
|
func (s *Service) ReportIgnore(c context.Context, oids, rpIDs []int64, adminID int64, adName string, typ, audit int32, remark string, delReport bool) (err error) { |
|
var ( |
|
state int32 |
|
op int32 |
|
result string |
|
action string |
|
) |
|
if audit == model.AuditTypeFirst { |
|
result = "一审忽略" |
|
op = model.AdminOperRptIgnore1 |
|
state = model.ReportStateIgnore1 |
|
action = model.ReportActionReportIgnore1 |
|
} else if audit == model.AuditTypeSecond { |
|
result = "二审忽略" |
|
op = model.AdminOperRptIgnore2 |
|
state = model.ReportStateIgnore2 |
|
action = model.ReportActionReportIgnore2 |
|
} else { |
|
err = ecode.RequestErr |
|
return |
|
} |
|
subs, err := s.subjects(c, oids, typ) |
|
if err != nil { |
|
log.Error("ReportIgnore subjects(%v,%v,%d) error(%v)", oids, typ, state, err) |
|
return |
|
} |
|
rps, err := s.replies(c, oids, rpIDs) |
|
if err != nil { |
|
log.Error("ReportIgnore replies(%v,%v,%d) error(%v)", oids, rpIDs, state, err) |
|
return |
|
} |
|
rpts, err := s.reports(c, oids, rpIDs) |
|
if err != nil { |
|
log.Error("ReportIgnore reports(%v,%v,%d) error(%v)", oids, rpIDs, state, err) |
|
return |
|
} |
|
now := time.Now() |
|
rows, err := s.dao.UpReportsState(c, oids, rpIDs, state, now) |
|
if err != nil { |
|
log.Error("ReportIgnore UpReportsState(%v,%v,%d) rows:%d error(%v)", oids, rpIDs, state, rows, err) |
|
return |
|
} else if rows == 0 { |
|
return |
|
} |
|
for _, rp := range rps { |
|
rpt, ok := rpts[rp.ID] |
|
if !ok { |
|
continue |
|
} |
|
sub, ok := subs[rpt.Oid] |
|
if !ok { |
|
continue |
|
} |
|
s.pubEvent(c, model.EventReportDel, rpt.Mid, sub, rp, rpt) |
|
} |
|
for _, rpt := range rpts { |
|
report.Manager(&report.ManagerInfo{ |
|
UID: adminID, |
|
Uname: adName, |
|
Business: 41, |
|
Type: int(typ), |
|
Oid: rpt.Oid, |
|
Ctime: now, |
|
Action: action, |
|
Index: []interface{}{ |
|
rpt.RpID, |
|
rpt.State, |
|
state, |
|
}, |
|
Content: map[string]interface{}{ |
|
"remark": remark, |
|
}, |
|
}) |
|
rpt.State = state |
|
rpt.MTime = xtime.Time(now.Unix()) |
|
if delReport { |
|
s.cache.Do(c, func(ctx context.Context) { |
|
s.dao.DelReport(ctx, rpt.Oid, rpt.RpID) |
|
}) |
|
} |
|
|
|
} |
|
s.addAdminLogs(c, rps, adminID, typ, model.AdminIsNew, model.AdminIsReport, op, result, remark, now) |
|
s.cache.Do(c, func(ctx context.Context) { |
|
s.pubSearchReport(ctx, rpts, nil) |
|
}) |
|
return |
|
} |
|
|
|
// ReportDel delete reply by report. |
|
func (s *Service) ReportDel(c context.Context, oids, rpIDs []int64, adminID, ftime int64, typ, audit, moral, reason, freason int32, notify bool, adminName, remark, content string) (err error) { |
|
return s.reportDel(c, oids, rpIDs, adminID, ftime, typ, audit, moral, reason, freason, notify, adminName, remark, content) |
|
} |
|
|
|
func (s *Service) reportDel(c context.Context, oids, rpIDs []int64, adminID, ftime int64, typ, audit, moral, reason, freason int32, notify bool, adminName, remark, content string) (err error) { |
|
var ( |
|
op int32 |
|
rptState int32 |
|
action string |
|
) |
|
if audit == model.AuditTypeFirst { |
|
op = model.AdminOperRptDel1 |
|
rptState = model.ReportStateDelete1 |
|
action = model.ReportActionReportDel1 |
|
} else if audit == model.AuditTypeSecond { |
|
op = model.AdminOperRptDel2 |
|
rptState = model.ReportStateDelete2 |
|
action = model.ReportActionReportDel2 |
|
} else { |
|
err = ecode.RequestErr |
|
return |
|
} |
|
now := time.Now() |
|
rpts, err := s.reports(c, oids, rpIDs) |
|
if err != nil { |
|
log.Error("reportDel reports(%v, %v) error(%v)", oids, rpIDs, err) |
|
return |
|
} |
|
|
|
wg, ctx := errgroup.WithContext(c) |
|
for _, rept := range rpts { |
|
rpt := rept |
|
wg.Go(func() (err error) { |
|
isPunish := false |
|
var sub *model.Subject |
|
var rp *model.Reply |
|
sub, rp, err = s.delReply(ctx, rpt.Oid, rpt.RpID, model.StateDelAdmin, now) |
|
if err != nil { |
|
if ecode.ReplyDeleted.Equal(err) && rp.IsDeleted() { |
|
isPunish = true |
|
err = nil |
|
} else { |
|
log.Error("reportDel tranDel(%d, %d) error(%v)", rpt.Oid, rpt.RpID, err) |
|
return err |
|
} |
|
} |
|
s.delCache(ctx, sub, rp) |
|
rea := reason |
|
if reason == -1 { |
|
rea = rpt.Reason |
|
} |
|
report.Manager(&report.ManagerInfo{ |
|
UID: adminID, |
|
Uname: adminName, |
|
Business: 41, |
|
Type: int(typ), |
|
Oid: rpt.Oid, |
|
Ctime: now, |
|
Action: action, |
|
Index: []interface{}{ |
|
rpt.RpID, |
|
rpt.State, |
|
rptState, |
|
}, |
|
Content: map[string]interface{}{ |
|
"moral": moral, |
|
"notify": notify, |
|
"ftime": ftime, |
|
"freason": freason, |
|
"reason": rea, |
|
"remark": remark, |
|
}, |
|
}) |
|
rpt.State = rptState |
|
rpt.MTime = xtime.Time(now.Unix()) |
|
rpt.ReplyCtime = rp.CTime |
|
s.pubEvent(ctx, model.EventReportDel, rpt.Mid, sub, rp, rpt) |
|
s.cache.Do(c, func(ctx context.Context) { |
|
s.dao.DelReport(ctx, rp.Oid, rp.ID) |
|
s.moralAndNotify(ctx, rp, moral, notify, rp.Mid, adminID, adminName, remark, rea, freason, ftime, isPunish) |
|
}) |
|
return nil |
|
}) |
|
} |
|
if err = wg.Wait(); err != nil { |
|
return |
|
} |
|
var rows int64 |
|
if reason == -1 { |
|
rows, err = s.dao.UpReportsState(c, oids, rpIDs, rptState, now) |
|
} else { |
|
rows, err = s.dao.UpReportsStateWithReason(c, oids, rpIDs, rptState, reason, content, now) |
|
} |
|
if err != nil || rows == 0 { |
|
return |
|
} |
|
s.cache.Do(c, func(ctx context.Context) { |
|
state := model.StateDelAdmin |
|
s.pubSearchReport(ctx, rpts, &state) |
|
}) |
|
s.addAdminIDLogs(c, oids, rpIDs, adminID, typ, model.AdminIsNew, model.AdminIsReport, op, fmt.Sprintf("已通过举报并删除封禁%s/扣除%d节操", forbidResult(ftime), moral), remark, now) |
|
|
|
return |
|
} |
|
|
|
// ReportRecover recover a report reply. |
|
func (s *Service) ReportRecover(c context.Context, oids, rpIDs []int64, adminID int64, typ, audit int32, remark string) (err error) { |
|
s.reportRecover(c, oids, rpIDs, adminID, typ, audit, remark) |
|
return |
|
} |
|
|
|
func (s *Service) reportRecover(c context.Context, oids, rpIDs []int64, adminID int64, typ, audit int32, remark string) (err error) { |
|
var ( |
|
rptState int32 |
|
op int32 |
|
result string |
|
) |
|
if audit == model.AuditTypeFirst { |
|
result = "一审恢复评论" |
|
op = model.AdminOperRptRecover1 |
|
rptState = model.ReportStateIgnore1 |
|
} else if audit == model.AuditTypeSecond { |
|
result = "二审恢复评论" |
|
op = model.AdminOperRptRecover2 |
|
rptState = model.ReportStateIgnore2 |
|
} else { |
|
err = ecode.RequestErr |
|
return |
|
} |
|
now := time.Now() |
|
rpts, err := s.reports(c, oids, rpIDs) |
|
if err != nil { |
|
log.Error("ReportRecover reports(%v, %v) error(%v)", oids, rpIDs, err) |
|
return |
|
} |
|
var rps = map[int64]*model.Reply{} |
|
wg, ctx := errgroup.WithContext(c) |
|
for _, report := range rpts { |
|
rpt := report |
|
wg.Go(func() (err error) { |
|
sub, rp, err := s.recReply(ctx, rpt.Oid, rpt.RpID, model.StateNormal, now) |
|
if err != nil { |
|
log.Error("ReportRecover tranRecover(%d, %d) error(%v)", rpt.Oid, rpt.RpID, err) |
|
return |
|
} |
|
rpt.MTime = xtime.Time(now.Unix()) |
|
rpt.State = rptState |
|
s.pubEvent(ctx, model.EventReportRecover, rpt.Mid, sub, rp, rpt) |
|
rps[rp.ID] = rp |
|
return |
|
}) |
|
} |
|
if err = wg.Wait(); err != nil { |
|
return |
|
} |
|
rows, err := s.dao.UpReportsState(c, oids, rpIDs, rptState, now) |
|
if err != nil { |
|
return |
|
} else if rows == 0 { |
|
return |
|
} |
|
s.addAdminIDLogs(c, oids, rpIDs, adminID, typ, model.AdminIsNew, model.AdminIsReport, op, result, remark, now) |
|
s.cache.Do(c, func(ctx context.Context) { |
|
s.pubSearchReply(ctx, rps, model.StateNormal) |
|
}) |
|
return |
|
} |
|
|
|
// ReportTransfer transfer a report. |
|
func (s *Service) ReportTransfer(c context.Context, oids, rpIDs []int64, adminID int64, adName string, typ, audit int32, remark string) (err error) { |
|
var ( |
|
state int32 |
|
op int32 |
|
result string |
|
action string |
|
) |
|
if audit == model.AuditTypeFirst { |
|
result = "二审转一审" |
|
op = model.AdminOperRptTransfer1 |
|
state = model.ReportStateNew |
|
action = model.ReportActionReport2To1 |
|
} else if audit == model.AuditTypeSecond { |
|
result = "一审转二审" |
|
op = model.AdminOperRptTransfer2 |
|
state = model.ReportStateNew2 |
|
action = model.ReportActionReport1To2 |
|
} else { |
|
err = ecode.RequestErr |
|
return |
|
} |
|
rpts, err := s.reports(c, oids, rpIDs) |
|
if err != nil { |
|
return |
|
} |
|
now := time.Now() |
|
var tranOids, tranRpIDs []int64 |
|
var tranRpt []*model.Report |
|
for _, rpt := range rpts { |
|
if rpt.AttrVal(model.ReportAttrTransferred) == model.AttrNo { |
|
rpt.State = state |
|
rpt.MTime = xtime.Time(now.Unix()) |
|
tranOids = append(tranOids, rpt.Oid) |
|
tranRpIDs = append(tranRpIDs, rpt.RpID) |
|
tranRpt = append(tranRpt, rpt) |
|
} |
|
} |
|
rows, err := s.dao.UpReportsState(c, tranOids, tranRpIDs, state, now) |
|
if err != nil { |
|
log.Error("s.dao.UpReportState(%v,%v,%d) rows:%d error(%v)", oids, rpIDs, state, rows, err) |
|
return |
|
} else if rows == 0 { |
|
return |
|
} |
|
for _, rpt := range tranRpt { |
|
report.Manager(&report.ManagerInfo{ |
|
UID: adminID, |
|
Uname: adName, |
|
Business: 41, |
|
Type: int(typ), |
|
Oid: rpt.Oid, |
|
Ctime: now, |
|
Action: action, |
|
Index: []interface{}{ |
|
rpt.RpID, |
|
rpt.State, |
|
state, |
|
}, |
|
Content: map[string]interface{}{ |
|
"remark": remark, |
|
}, |
|
}) |
|
} |
|
if _, err = s.dao.UpReportsAttrBit(c, tranOids, tranRpIDs, model.ReportAttrTransferred, model.AttrYes, now); err != nil { |
|
log.Error("s.dao.UpReportAttrBit(%v,%v) transfered errror(%v)", tranOids, tranRpIDs, err) |
|
return |
|
} |
|
s.addAdminIDLogs(c, oids, rpIDs, adminID, typ, model.AdminIsNew, model.AdminIsReport, op, result, remark, now) |
|
s.cache.Do(c, func(ctx context.Context) { |
|
s.pubSearchReport(ctx, rpts, nil) |
|
}) |
|
return |
|
} |
|
|
|
// ReportStateSet transfer a report. |
|
func (s *Service) ReportStateSet(c context.Context, oids, rpIDs []int64, adminID int64, adname string, typ, state int32, remark string, delReport bool) (err error) { |
|
if state != model.ReportStateTransferred { |
|
return |
|
} |
|
var ( |
|
op int32 |
|
result string |
|
action string |
|
) |
|
op = model.AdminOperRptTransferArbitration |
|
action = model.ReportActionReportArbitration |
|
if adminID == 0 { |
|
result = "系统自动移交至风纪委" |
|
} else { |
|
result = "管理员移交至风纪委" |
|
} |
|
rpts, err := s.reports(c, oids, rpIDs) |
|
if err != nil { |
|
return |
|
} |
|
rps, err := s.replies(c, oids, rpIDs) |
|
if err != nil { |
|
log.Error("s.replies (%v,%v) error(%v)", oids, rpIDs, err) |
|
return |
|
} |
|
links := make(map[int64]string, 0) |
|
titles := make(map[int64]string, 0) |
|
for _, rp := range rps { |
|
title, link, _ := s.TitleLink(c, rp.Oid, rp.Type) |
|
links[rp.ID] = link |
|
titles[rp.ID] = title |
|
} |
|
err = s.dao.TransferArbitration(c, rps, rpts, adminID, adname, titles, links) |
|
if err != nil { |
|
log.Error("s.dao.TransferArbitration (%v,%v) error(%v)", rps, rpts, err) |
|
return |
|
} |
|
mtime := time.Now() |
|
for _, rpt := range rpts { |
|
report.Manager(&report.ManagerInfo{ |
|
UID: adminID, |
|
Uname: adname, |
|
Business: 41, |
|
Type: int(typ), |
|
Oid: rpt.Oid, |
|
Ctime: mtime, |
|
Action: action, |
|
Index: []interface{}{ |
|
rpt.RpID, |
|
rpt.State, |
|
state, |
|
}, |
|
Content: map[string]interface{}{ |
|
"remark": remark, |
|
}, |
|
}) |
|
rpt.State = state |
|
rpt.MTime = xtime.Time(mtime.Unix()) |
|
if delReport { |
|
s.cache.Do(c, func(ctx context.Context) { |
|
s.dao.DelReport(ctx, rpt.Oid, rpt.RpID) |
|
}) |
|
} |
|
} |
|
rows, err := s.dao.UpReportsState(c, oids, rpIDs, state, mtime) |
|
if err != nil { |
|
log.Error("s.dao.UpReportState(%v,%v,%d) rows:%d error(%v)", oids, rpIDs, state, rows, err) |
|
return |
|
} else if rows == 0 { |
|
return |
|
} |
|
s.addAdminIDLogs(c, oids, rpIDs, adminID, typ, model.AdminIsNew, model.AdminIsReport, op, result, remark, mtime) |
|
s.cache.Do(c, func(ctx context.Context) { |
|
s.pubSearchReport(ctx, rpts, nil) |
|
}) |
|
return |
|
}
|
|
|