895 lines
29 KiB
Go
895 lines
29 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
|
|
"go-common/app/job/main/reply/model/reply"
|
|
model "go-common/app/job/main/reply/model/reply"
|
|
xsql "go-common/library/database/sql"
|
|
"go-common/library/log"
|
|
xtime "go-common/library/time"
|
|
)
|
|
|
|
const (
|
|
_eventReportAdd = "report_add"
|
|
_eventReportDel = "report_del"
|
|
_eventReportIgnore = "report_ignore"
|
|
_eventReportRecover = "report_recover"
|
|
)
|
|
|
|
func (s *Service) actionAdmin(c context.Context, msg *consumerMsg) {
|
|
var d struct {
|
|
Op string `json:"op"`
|
|
Adid int64 `json:"adid"`
|
|
AdName string `json:"adname"`
|
|
Oid int64 `json:"oid"`
|
|
RpID int64 `json:"rpid"`
|
|
Mid int64 `json:"mid"`
|
|
Tp int8 `json:"tp"`
|
|
Action uint32 `json:"action"`
|
|
Moral int `json:"moral"`
|
|
Notify bool `json:"notify"`
|
|
Remark string `json:"remark"`
|
|
MTime xtime.Time `json:"mtime"`
|
|
Ftime int64 `json:"ftime"`
|
|
Audit int8 `json:"audit"`
|
|
Reason int8 `json:"reason"`
|
|
Content string `json:"content"`
|
|
FReason int8 `json:"freason"`
|
|
Assist bool `json:"assist"`
|
|
State int8 `json:"state"`
|
|
}
|
|
if err := json.Unmarshal([]byte(msg.Data), &d); err != nil {
|
|
log.Error("json.Unmarshal() error(%v)", err)
|
|
return
|
|
}
|
|
if d.Oid <= 0 || d.RpID <= 0 {
|
|
log.Error("The structure of msg.Data(%s) was wrong", msg.Data)
|
|
return
|
|
}
|
|
rp, err := s.getReply(c, d.Oid, d.RpID)
|
|
if err != nil {
|
|
log.Error("s.getReply failed , oid(%d), RpID(%d) err(%v)", d.Oid, d.RpID, err)
|
|
return
|
|
}
|
|
if rp == nil {
|
|
log.Error("getReply nil oid(%d) RpID(%d)", d.Oid, d.RpID)
|
|
return
|
|
}
|
|
switch {
|
|
case d.Op == "del":
|
|
s.adminDel(c, rp, d.Adid, d.Mid, d.Ftime, d.Moral, d.AdName, d.Remark, d.MTime, d.Notify, d.Reason, d.FReason)
|
|
case d.Op == "del_rpt":
|
|
s.reportDel(c, rp, d.Adid, d.Mid, d.Ftime, d.Moral, d.AdName, d.Remark, d.MTime, d.Notify, d.Audit, d.Reason, d.Content, d.FReason)
|
|
case d.Op == "del_up":
|
|
s.userDel(c, rp, d.Mid, d.MTime, d.Remark, d.Assist)
|
|
case d.Op == "re", d.Op == "pass":
|
|
s.passReply(c, rp, d.MTime, d.Adid, d.Remark, d.Op)
|
|
case d.Op == "edit":
|
|
s.addSearchUp(c, rp.State, rp, nil)
|
|
case d.Op == "ignore":
|
|
s.reportIgnore(c, rp, d.Audit, d.MTime, d.Adid, d.Remark)
|
|
case d.Op == "transfer":
|
|
s.reportTransfer(c, rp, d.Audit, d.MTime, d.Adid, d.Remark)
|
|
case d.Op == "stateset":
|
|
s.reportStateSet(c, rp, d.State, d.MTime, d.Adid, d.Remark)
|
|
case d.Op == "top_add":
|
|
err := s.topAdd(c, rp, d.MTime, d.Action, model.SubAttrAdminTop)
|
|
if err != nil {
|
|
log.Error("s.topAdd(oid:%d,tp:%d err(%v))", rp.Oid, rp.Type, err)
|
|
return
|
|
}
|
|
// s.dao.Redis.AddTopOid(c, rp.Oid, rp.Type)
|
|
s.adminLog(c, rp, d.Adid, model.AdminIsReport, model.AdminOperSubTop, "管理员置顶评论", d.Remark)
|
|
s.addSearchUp(c, rp.State, rp, nil)
|
|
case d.Op == "rpt_re":
|
|
s.reportRecover(c, rp, d.Audit, d.MTime, d.Adid, d.Remark)
|
|
}
|
|
}
|
|
|
|
func (s *Service) reportStateSet(c context.Context, rp *model.Reply, state int8, mtime xtime.Time, adid int64, remark string) (err error) {
|
|
var (
|
|
op int8
|
|
result string
|
|
oldState = rp.State
|
|
)
|
|
rpt, err := s.dao.Report.Get(c, rp.Oid, rp.RpID)
|
|
if err != nil || rpt == nil {
|
|
log.Error("dao.Report.GetReport(%d, %d) met error (%v)", rp.Oid, rp.RpID, err)
|
|
return
|
|
}
|
|
|
|
rpt.State = state
|
|
rpt.MTime = mtime
|
|
|
|
op = model.AdminOperRptTransferArbitration
|
|
if adid == 0 {
|
|
result = "系统自动移交至风纪委"
|
|
} else {
|
|
result = "管理员移交至风纪委"
|
|
}
|
|
if _, err = s.dao.Report.Update(c, rpt); err != nil {
|
|
log.Error("dao.Report.Update(%v) error(%v)", rpt, err)
|
|
return
|
|
}
|
|
// admin log
|
|
s.adminLog(c, rp, adid, model.AdminIsReport, op, result, remark)
|
|
s.addSearchUp(c, oldState, rp, rpt)
|
|
return
|
|
}
|
|
|
|
func (s *Service) reportTransfer(c context.Context, rp *model.Reply, audit int8, mtime xtime.Time, adid int64, remark string) (err error) {
|
|
var (
|
|
op int8
|
|
result string
|
|
oldState = rp.State
|
|
)
|
|
rpt, err := s.dao.Report.Get(c, rp.Oid, rp.RpID)
|
|
if err != nil || rpt == nil {
|
|
log.Error("dao.Report.GetReport(%d, %d) met error (%v)", rp.Oid, rp.RpID, err)
|
|
return
|
|
}
|
|
if rpt.IsTransferred() {
|
|
log.Error("report(%v) has been transfferd before!", *rpt)
|
|
return
|
|
}
|
|
if audit == model.AuditTypeOne {
|
|
rpt.State = model.ReportStateNew
|
|
op = model.AdminOperRptTransfer1
|
|
result = "二审转一审"
|
|
} else if audit == model.AuditTypeTwo {
|
|
rpt.State = model.ReportStateNewTwo
|
|
op = model.AdminOperRptTransfer2
|
|
result = "一审转二审"
|
|
}
|
|
rpt.MTime = mtime
|
|
rpt.SetTransferred()
|
|
if _, err = s.dao.Report.Update(c, rpt); err != nil {
|
|
log.Error("dao.Report.Update(%v) error(%v)", rpt, err)
|
|
return
|
|
}
|
|
// admin log
|
|
s.adminLog(c, rp, adid, model.AdminIsReport, op, result, remark)
|
|
s.addSearchUp(c, oldState, rp, rpt)
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Service) reportIgnore(c context.Context, rp *model.Reply, audit int8, mtime xtime.Time, adid int64, remark string) (err error) {
|
|
var (
|
|
op int8
|
|
result string
|
|
oldState = rp.State
|
|
)
|
|
rpt, err := s.dao.Report.Get(c, rp.Oid, rp.RpID)
|
|
if err != nil || rpt == nil {
|
|
log.Error("dao.Report.GetReport(%d, %d) met error (%v)", rp.Oid, rp.RpID, err)
|
|
return
|
|
}
|
|
if audit == model.AuditTypeOne {
|
|
rpt.State = model.ReportStateIgnoreOne
|
|
op = model.AdminOperRptIgnore1
|
|
result = "一审忽略"
|
|
} else if audit == model.AuditTypeTwo {
|
|
rpt.State = model.ReportStateIgnoreTwo
|
|
op = model.AdminOperRptIgnore2
|
|
result = "二审忽略"
|
|
} else {
|
|
if rpt.State == model.ReportStateNew {
|
|
rpt.State = model.ReportStateIgnoreOne
|
|
} else {
|
|
rpt.State = model.ReportStateIgnoreTwo
|
|
}
|
|
op = model.AdminOperIgnoreReport
|
|
result = "已忽略举报"
|
|
}
|
|
rpt.MTime = mtime
|
|
if _, err = s.dao.Report.Update(c, rpt); err != nil {
|
|
log.Error("dao.Report.Update(%v) error(%v)", rpt, err)
|
|
return
|
|
}
|
|
// admin log
|
|
s.adminLog(c, rp, adid, model.AdminIsReport, op, result, remark)
|
|
s.addSearchUp(c, oldState, rp, rpt)
|
|
|
|
sub, err := s.getSubject(c, rp.Oid, rp.Type)
|
|
if err != nil || sub == nil {
|
|
log.Error("s.getSubject(%v,%v) err(%v) or sub nil", sub.Oid, sub.Type, err)
|
|
return
|
|
}
|
|
if err = s.dao.PubEvent(c, _eventReportIgnore, rpt.Mid, sub, rp, rpt); err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) reportRecover(c context.Context, rp *model.Reply, audit int8, mtime xtime.Time, adid int64, remark string) (err error) {
|
|
var (
|
|
ok bool
|
|
op int8
|
|
result string
|
|
rootRp *model.Reply
|
|
oldState = rp.State
|
|
)
|
|
isRoot := rp.Root == 0 && rp.Parent == 0
|
|
rpt, _ := s.dao.Report.Get(c, rp.Oid, rp.RpID)
|
|
if err != nil || rpt == nil {
|
|
log.Error("dao.Report.GetReport(%d, %d) met error (%v)", rp.Oid, rp.RpID, err)
|
|
return
|
|
}
|
|
sub, err := s.getSubject(c, rp.Oid, rp.Type)
|
|
if err != nil || sub == nil {
|
|
log.Error("s.getSubject(%v,%v) err(%v) or sub nil", sub.Oid, sub.Type, err)
|
|
return
|
|
}
|
|
if audit == model.AuditTypeOne {
|
|
// 一审移除，恢复到待一审忽略，评论正常
|
|
rpt.State = model.ReportStateIgnoreOne
|
|
op = model.AdminOperRptRecover1
|
|
result = "一审恢复评论"
|
|
} else if audit == model.AuditTypeTwo {
|
|
// 二审移除，恢复到二审忽略，评论正常
|
|
rpt.State = model.ReportStateIgnoreTwo
|
|
op = model.AdminOperRptRecover2
|
|
result = "二审恢复评论"
|
|
} else {
|
|
log.Error("reportRecover unsupport audit: %d", audit)
|
|
return
|
|
}
|
|
rpt.MTime = mtime
|
|
if _, err = s.dao.Report.Update(c, rpt); err != nil {
|
|
log.Error("dao.Report.Update(%v) error(%v) or row==0", rpt, err)
|
|
return
|
|
}
|
|
// 只恢复管理员删除的评论，不恢复用户删除的
|
|
if rp.State == model.ReplyStateAdminDel {
|
|
rp.MTime = mtime
|
|
rp.State = model.ReplyStateNormal
|
|
if err = s.tranRecover(c, rp, model.ReplyStateNormal, isRoot); err != nil {
|
|
log.Error("Transaction recover reply failed err(%v)", err)
|
|
return
|
|
}
|
|
}
|
|
// add cache
|
|
if isRoot {
|
|
if err = s.dao.Mc.AddReply(c, rp); err != nil {
|
|
log.Error("s.dao.Mc.AddReply failed , RpID(%d), err(%v)", rp.RpID, err)
|
|
}
|
|
if err = s.dao.Redis.AddIndex(c, rp.Oid, rp.Type, rpt, rp, true); err != nil {
|
|
log.Error("s.dao.Redis.AddIndex(%d, %d) error(%v)", rp.Oid, rp.Type, err)
|
|
}
|
|
} else {
|
|
if ok, err = s.dao.Redis.ExpireNewChildIndex(c, rp.Root); err == nil && ok {
|
|
if err = s.dao.Redis.AddNewChildIndex(c, rp.Root, rp); err != nil {
|
|
log.Error("s.dao.Redis.AddFloorIndexByRoot failed , rproot(%d), err(%v)", rp.Root, err)
|
|
}
|
|
}
|
|
if rootRp, err = s.getReplyCache(c, rp.Oid, rp.Root); err != nil {
|
|
log.Error("s.getReply failed , oid(%d), root(%d) err(%v)", rp.Oid, rp.Root, err)
|
|
} else if rootRp != nil {
|
|
rootRp.RCount++
|
|
if err = s.dao.Mc.AddReply(c, rootRp); err != nil {
|
|
log.Error("s.dao.Mc.AddReply failed , RpID(%d) err(%v)", rootRp.RpID, err)
|
|
}
|
|
}
|
|
}
|
|
// log
|
|
s.adminLog(c, rp, adid, model.AdminIsReport, op, result, remark)
|
|
// notify
|
|
s.addSearchUp(c, oldState, rp, rpt)
|
|
s.upAcount(c, sub.Oid, sub.Type, sub.ACount, rp.CTime.Time())
|
|
|
|
if err = s.dao.PubEvent(c, _eventReportRecover, rpt.Mid, sub, rp, rpt); err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// topAdd add top reply
|
|
func (s *Service) topAdd(c context.Context, rp *model.Reply, ts xtime.Time, act uint32, tp uint32) (err error) {
|
|
sub, err := s.getSubject(c, rp.Oid, rp.Type)
|
|
if err != nil || sub == nil {
|
|
log.Error("s.getsubject(%v,%v) err(%v) or sub nil", rp.Oid, rp.Type, err)
|
|
return
|
|
}
|
|
if act == 1 && sub.AttrVal(tp) == 1 {
|
|
log.Error("Repeat to add top reply(%d,%d,%d,%d) ", rp.RpID, rp.Oid, tp, sub.Attr)
|
|
return
|
|
}
|
|
err = sub.TopSet(rp.RpID, tp, act)
|
|
if err != nil {
|
|
log.Error("sub.TopSet(%d,%d,%d) failed!err:=%v ", rp.RpID, rp.Oid, tp, err)
|
|
return
|
|
}
|
|
sub.AttrSet(act, tp)
|
|
rp.AttrSet(act, tp)
|
|
tx, err := s.beginTran(c)
|
|
if err != nil {
|
|
log.Error("s.beginTran() err(%v)", err)
|
|
return
|
|
}
|
|
var rows int64
|
|
//rp.State = model.ReplyStateTop
|
|
if rows, err = s.dao.Reply.TxUpAttr(tx, rp.Oid, rp.RpID, rp.Attr, ts.Time()); err != nil || rows == 0 {
|
|
tx.Rollback()
|
|
log.Error("dao.Reply.UpState(%v, %d) error(%v) or row==0", rp, rp.State, err)
|
|
return
|
|
}
|
|
if rows, err = s.dao.Subject.TxUpMeta(tx, sub.Oid, sub.Type, sub.Meta, ts.Time()); err != nil || rows == 0 {
|
|
tx.Rollback()
|
|
log.Error("dao.TxUpMeta(oid:%d,tp:%d) err(%v) rows(%d)", sub.Oid, sub.Type, err, rows)
|
|
return
|
|
}
|
|
if rows, err = s.dao.Subject.TxUpAttr(tx, sub.Oid, sub.Type, sub.Attr, ts.Time()); err != nil || rows == 0 {
|
|
tx.Rollback()
|
|
log.Error("dao.Upattr(oid:%d,tp:%d) err(%v) rows(%d)", sub.Oid, sub.Type, err, rows)
|
|
return
|
|
}
|
|
tx.Commit()
|
|
s.dao.Mc.AddSubject(c, sub)
|
|
if act == 1 {
|
|
s.dao.Redis.DelIndexBySortType(c, rp, reply.SortByCount)
|
|
s.dao.Redis.DelIndexBySortType(c, rp, reply.SortByLike)
|
|
} else if rp.IsNormal() {
|
|
if ok, err := s.dao.Redis.ExpireIndex(c, sub.Oid, sub.Type, model.SortByCount); err == nil && ok {
|
|
if err = s.dao.Redis.AddCountIndex(c, sub.Oid, sub.Type, rp); err != nil {
|
|
log.Error("s.dao.Redis.AddCountIndex failed , oid(%d) type(%d) err(%v)", sub.Oid, sub.Type, err)
|
|
}
|
|
}
|
|
if ok, err := s.dao.Redis.ExpireIndex(c, sub.Oid, sub.Type, model.SortByLike); err == nil && ok {
|
|
rpts := make(map[int64]*reply.Report, 1)
|
|
if rpt, _ := s.dao.Report.Get(c, rp.Oid, rp.RpID); rpt != nil {
|
|
rpts[rp.RpID] = rpt
|
|
}
|
|
if err = s.dao.Redis.AddLikeIndex(c, sub.Oid, sub.Type, rpts, rp); err != nil {
|
|
log.Error("s.dao.Redis.AddLikeIndex failed , oid(%d) type(%d) err(%v)", sub.Oid, sub.Type, err)
|
|
}
|
|
}
|
|
}
|
|
s.dao.Mc.AddReply(c, rp)
|
|
s.dao.Mc.AddTop(c, rp)
|
|
if act == 1 {
|
|
s.dao.PubEvent(c, "top", 0, sub, rp, nil)
|
|
} else if act == 0 {
|
|
s.dao.PubEvent(c, "untop", 0, sub, rp, nil)
|
|
}
|
|
// 折叠评论被置顶自动取消折叠
|
|
if rp.IsFolded() && act == 1 {
|
|
rp.State = model.ReplyStateNormal
|
|
s.marker.Do(c, func(ctx context.Context) {
|
|
if _, err := s.dao.Reply.UpState(ctx, rp.Oid, rp.RpID, rp.State, time.Now()); err == nil {
|
|
if ok, err := s.dao.Redis.ExpireIndex(c, rp.Oid, rp.Type, model.SortByFloor); err == nil && ok {
|
|
s.dao.Redis.AddFloorIndex(c, rp.Oid, rp.Type, rp)
|
|
}
|
|
s.handleFolded(ctx, rp)
|
|
}
|
|
})
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) userDel(c context.Context, rp *model.Reply, mid int64, mtime xtime.Time, remark string, assist bool) (err error) {
|
|
var (
|
|
state int8
|
|
sub *model.Subject
|
|
oldState = rp.State
|
|
isRoot = rp.Root == 0 && rp.Parent == 0
|
|
isFolded = rp.IsFolded()
|
|
)
|
|
if rp.IsDeleted() {
|
|
s.addSearchUp(c, oldState, rp, nil)
|
|
return
|
|
}
|
|
if sub, err = s.dao.Subject.Get(c, rp.Oid, rp.Type); err != nil || sub == nil {
|
|
log.Error("s.dao.Subject.Get(%d,%d) error(%v)", rp.Oid, rp.Type, err)
|
|
return
|
|
}
|
|
if rp.Mid == mid {
|
|
state = model.ReplyStateUserDel
|
|
} else if assist {
|
|
state = model.ReplyStateAssistDel
|
|
} else if mid > 0 {
|
|
state = model.ReplyStateUpDel
|
|
} else {
|
|
state = model.ReplyStateAdminDel
|
|
}
|
|
rp.MTime = mtime
|
|
if err = s.tranDel(c, rp, state, sub, isRoot); err != nil {
|
|
log.Error("reportDel tranDel(%d, %d) error(%v)", rp.Oid, rp.RpID, err)
|
|
return
|
|
}
|
|
if isFolded {
|
|
s.marker.Do(c, func(ctx context.Context) {
|
|
s.handleFolded(ctx, rp)
|
|
})
|
|
}
|
|
if err = s.clearReplyCache(c, rp); err != nil {
|
|
log.Error("reportDel clearReplyCache(%d, %d) error(%v)", rp.Oid, rp.RpID, err)
|
|
}
|
|
rp.State = state
|
|
if rp.Mid == mid {
|
|
s.adminLog(c, rp, mid, model.AdminIsNotReport, model.AdminOperDeleteUser, "由本人删除", remark)
|
|
s.searchDao.DelReply(c, rp.RpID, sub.Oid, mid, state)
|
|
} else if assist {
|
|
s.adminLog(c, rp, mid, model.AdminIsNotReport, model.AdminOperDeleteAssist, "由UP主协管员删除", remark)
|
|
s.addAssistLog(c, sub.Mid, mid, sub.Oid, 1, 1, strconv.FormatInt(rp.RpID, 10), rp.Content.Message)
|
|
} else if mid > 0 {
|
|
s.adminLog(c, rp, mid, model.AdminIsNotReport, model.AdminOperDeleteUp, "由up主删除", remark)
|
|
} else {
|
|
s.adminLog(c, rp, 0, model.AdminIsNotReport, model.AdminOperDelete, "由系统删除", remark)
|
|
}
|
|
s.dao.PubEvent(c, "reply_del", rp.Mid, sub, rp, nil)
|
|
return
|
|
}
|
|
|
|
func (s *Service) adminDel(c context.Context, rp *model.Reply, adid, mid, ftime int64, moral int, adName, remark string, mtime xtime.Time, notify bool, reason, freason int8) (err error) {
|
|
var (
|
|
sub *model.Subject
|
|
report *model.Report
|
|
oldState = rp.State
|
|
isRoot = rp.Root == 0 && rp.Parent == 0
|
|
isFolded = rp.IsFolded()
|
|
)
|
|
if rp.IsDeleted() {
|
|
s.addSearchUp(c, oldState, rp, nil)
|
|
return
|
|
}
|
|
if sub, err = s.dao.Subject.Get(c, rp.Oid, rp.Type); err != nil || sub == nil {
|
|
log.Error("s.dao.Subject.Get(%d,%d) error(%v)", rp.Oid, rp.Type, err)
|
|
return
|
|
}
|
|
rp.MTime = mtime
|
|
if err = s.tranDel(c, rp, model.ReplyStateAdminDel, sub, isRoot); err != nil {
|
|
log.Error("reportDel tranDel(%d, %d) error(%v)", rp.Oid, rp.RpID, err)
|
|
return
|
|
}
|
|
if isFolded {
|
|
s.marker.Do(c, func(ctx context.Context) {
|
|
s.handleFolded(ctx, rp)
|
|
})
|
|
}
|
|
if err = s.clearReplyCache(c, rp); err != nil {
|
|
log.Error("reportDel clearReplyCache(%d, %d) error(%v)", rp.Oid, rp.RpID, err)
|
|
}
|
|
if report, err = s.dao.Report.Get(c, rp.Oid, rp.RpID); err != nil {
|
|
log.Error("reportDel getReport(%d,%d) error(%v)", rp.Oid, rp.RpID, err)
|
|
return
|
|
}
|
|
if report != nil {
|
|
if report.State == model.ReportStateNew || report.State == model.ReportStateNewTwo {
|
|
if report.State == model.ReportStateNew {
|
|
report.State = model.ReportStateDeleteOne
|
|
} else if report.State == model.ReportStateNewTwo {
|
|
report.State = model.ReportStateDeleteTwo
|
|
}
|
|
report.MTime = mtime
|
|
if _, err = s.dao.Report.Update(c, report); err != nil {
|
|
log.Error("reportDel updateReport(%d, %d) error(%v)", report.Oid, report.ID, err)
|
|
return
|
|
}
|
|
s.addSearchUp(c, oldState, rp, report)
|
|
s.dao.PubEvent(c, _eventReportDel, 0, sub, rp, report)
|
|
}
|
|
}
|
|
rp.State = model.ReplyStateAdminDel
|
|
// add moral and notify
|
|
s.moralAndNotify(c, rp, moral, notify, mid, adid, adName, remark, reason, freason, ftime, false)
|
|
// forbidden tip
|
|
forbidDay := strconv.FormatInt(ftime, 10) + "天"
|
|
if ftime == -1 {
|
|
forbidDay = "永久"
|
|
}
|
|
s.adminLog(c, rp, adid, model.AdminIsNotReport, model.AdminOperDelete, fmt.Sprintf("已删除并封禁%s/扣除%d节操", forbidDay, moral), remark)
|
|
s.addSearchUp(c, oldState, rp, nil)
|
|
if report == nil {
|
|
s.dao.PubEvent(c, "reply_del", 0, sub, rp, nil)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) reportDel(c context.Context, rp *model.Reply, adid, mid, ftime int64, moral int, adName, remark string, mtime xtime.Time, notify bool, audit int8, reason int8, content string, freason int8) (err error) {
|
|
var (
|
|
op int8
|
|
isPunish bool
|
|
sub *model.Subject
|
|
report *model.Report
|
|
oldState = rp.State
|
|
)
|
|
if sub, err = s.dao.Subject.Get(c, rp.Oid, rp.Type); err != nil || sub == nil {
|
|
log.Error("s.dao.Subject.Get(%d,%d) error(%v)", rp.Oid, rp.Type, err)
|
|
return
|
|
}
|
|
if report, err = s.dao.Report.Get(c, rp.Oid, rp.RpID); err != nil || report == nil {
|
|
log.Error("reportDel getReport(%d,%d) error(%v)", rp.Oid, rp.RpID, err)
|
|
return
|
|
}
|
|
report.MTime = mtime
|
|
// 一审、二审操作
|
|
switch audit {
|
|
case model.AuditTypeOne:
|
|
report.State = model.ReportStateDeleteOne
|
|
op = model.AdminOperRptDel1
|
|
case model.AuditTypeTwo:
|
|
report.State = model.ReportStateDeleteTwo
|
|
op = model.AdminOperRptDel2
|
|
default:
|
|
report.State = model.ReportStateDelete
|
|
op = model.AdminOperDeleteByReport
|
|
}
|
|
report.Reason = reason
|
|
report.Content = content
|
|
if _, err = s.dao.Report.Update(c, report); err != nil {
|
|
log.Error("reportDel updateReport(%d, %d) error(%v)", report.Oid, report.ID, err)
|
|
return
|
|
}
|
|
if !rp.IsDeleted() {
|
|
isRoot := rp.Root == 0 && rp.Parent == 0
|
|
rp.MTime = mtime
|
|
if err = s.tranDel(c, rp, model.ReplyStateAdminDel, sub, isRoot); err != nil {
|
|
log.Error("reportDel tranDel(%d, %d) error(%v)", rp.Oid, rp.RpID, err)
|
|
return
|
|
}
|
|
if err = s.clearReplyCache(c, rp); err != nil {
|
|
log.Error("reportDel clearReplyCache(%d, %d) error(%v)", rp.Oid, rp.RpID, err)
|
|
}
|
|
rp.State = model.ReplyStateAdminDel
|
|
} else {
|
|
isPunish = true
|
|
}
|
|
// add moral and notify
|
|
s.moralAndNotify(c, rp, moral, notify, mid, adid, adName, remark, reason, freason, ftime, isPunish)
|
|
// forbidden tip
|
|
forbidDay := strconv.FormatInt(ftime, 10) + "天"
|
|
if ftime == -1 {
|
|
forbidDay = "永久"
|
|
}
|
|
s.adminLog(c, rp, adid, model.AdminIsReport, op, fmt.Sprintf("已通过举报删除并封禁%s/扣除%d节操", forbidDay, moral), remark)
|
|
s.addSearchUp(c, oldState, rp, report)
|
|
|
|
if err = s.dao.PubEvent(c, _eventReportDel, report.Mid, sub, rp, report); err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) clearReplyCache(c context.Context, rp *model.Reply) (err error) {
|
|
var (
|
|
sub *model.Subject
|
|
rootRp *model.Reply
|
|
isRoot = rp.Root == 0 && rp.Parent == 0
|
|
)
|
|
if !isRoot && rp.IsNormal() {
|
|
// update root cache for count.
|
|
if rootRp, err = s.getReplyCache(c, rp.Oid, rp.Root); err != nil {
|
|
return
|
|
}
|
|
if rootRp != nil {
|
|
rootRp.RCount--
|
|
if err = s.addReplyCache(c, rootRp); err != nil {
|
|
log.Error("s.dao.Mc.addReplyCache(%d,%d,%d) error(%v)", rp.Oid, rp.Type, rp.RpID, err)
|
|
}
|
|
}
|
|
}
|
|
if rp.IsAdminTop() {
|
|
s.dao.Mc.DeleteTop(c, rp, model.ReplyAttrAdminTop)
|
|
}
|
|
if rp.IsUpTop() {
|
|
s.dao.Mc.DeleteTop(c, rp, model.ReplyAttrUpperTop)
|
|
}
|
|
if err = s.dao.Mc.DeleteReply(c, rp.RpID); err != nil {
|
|
log.Error("s.dao.Mc.DeleteReply failed , RpID(%d), err(%v)", rp.RpID, err)
|
|
}
|
|
if err = s.dao.Redis.DelIndex(c, rp); err != nil {
|
|
log.Error("s.dao.Redis.DelIndex failed , RpID(%d), err(%v)", rp.RpID, err)
|
|
}
|
|
if rp.State == model.ReplyStateAudit {
|
|
s.eraseAuditIndex(c, rp)
|
|
}
|
|
// update reply count
|
|
sub, err = s.dao.Subject.Get(c, rp.Oid, rp.Type)
|
|
if err != nil || sub == nil {
|
|
log.Error("s.dao.Subject.Get(%d,%d) error(%v)", rp.Oid, rp.Type, err)
|
|
return
|
|
}
|
|
if err = s.dao.Mc.AddSubject(c, sub); err != nil {
|
|
log.Error("s.dao.Mc.AddSubject failed , oid(%d), err(%v)", sub.Oid, err)
|
|
}
|
|
s.upAcount(c, sub.Oid, sub.Type, sub.ACount, rp.CTime.Time())
|
|
return
|
|
}
|
|
|
|
func (s *Service) passReply(c context.Context, rp *model.Reply, mtime xtime.Time, adid int64, remark, op string) {
|
|
var (
|
|
err error
|
|
ok bool
|
|
rootRp *model.Reply
|
|
oldState = rp.State
|
|
isRoot = rp.Root == 0 && rp.Parent == 0
|
|
)
|
|
sub, err := s.dao.Subject.Get(c, rp.Oid, rp.Type)
|
|
if err != nil || sub == nil {
|
|
log.Error("s.dao.Subject.Get(%d,%d) error(%v)", rp.Oid, rp.Type, err)
|
|
return
|
|
}
|
|
if rp.State <= model.ReplyStateHidden {
|
|
s.addSearchUp(c, oldState, rp, nil)
|
|
return
|
|
}
|
|
rp.MTime = mtime
|
|
rp.State = model.ReplyStateNormal
|
|
if op == "re" || oldState == model.ReplyStateAudit {
|
|
if err = s.tranRecover(c, rp, model.ReplyStateNormal, isRoot); err != nil {
|
|
log.Error("Transaction recover reply failed err(%v)", err)
|
|
return
|
|
}
|
|
} else if op == "pass" {
|
|
var row int64
|
|
var tx *xsql.Tx
|
|
tx, err = s.dao.BeginTran(c)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if row, err = s.dao.Reply.TxUpState(tx, rp.Oid, rp.RpID, model.ReplyStateNormal, mtime.Time()); err != nil || row == 0 {
|
|
tx.Rollback()
|
|
log.Error("dao.Reply.TxUpState(%v, %d) error(%v) or row==0", rp, model.ReplyStateNormal, err)
|
|
return
|
|
}
|
|
if rp.State == model.ReplyStateAudit || rp.State == model.ReplyStateMonitor {
|
|
if _, err = s.dao.Subject.TxDecrMCount(tx, rp.Oid, rp.Type, mtime.Time()); err != nil {
|
|
tx.Rollback()
|
|
log.Error("dao.Reply.TxDecrMCount(%v) error(%v)", rp, err)
|
|
return
|
|
}
|
|
}
|
|
if err = tx.Commit(); err != nil {
|
|
log.Error("tx.Commit error(%v)", err)
|
|
return
|
|
}
|
|
}
|
|
if isRoot {
|
|
if ok, err = s.dao.Redis.ExpireIndex(c, rp.Oid, rp.Type, model.SortByFloor); err == nil && ok {
|
|
var min int
|
|
min, err = s.dao.Redis.MinScore(c, rp.Oid, rp.Type, reply.SortByFloor)
|
|
if err != nil {
|
|
log.Error("s.dao.Redis.AddFloorIndex failed , oid(%d) type(%d) err(%v)", rp.Oid, rp.Type, err)
|
|
} else if rp.Floor > min {
|
|
if err = s.dao.Redis.AddFloorIndex(c, rp.Oid, rp.Type, rp); err != nil {
|
|
log.Error("s.dao.Redis.AddFloorIndex failed , RpID(%d), err(%v)", rp.RpID, err)
|
|
}
|
|
}
|
|
}
|
|
if ok, err = s.dao.Redis.ExpireIndex(c, rp.Oid, rp.Type, model.SortByCount); err == nil && ok {
|
|
if err = s.dao.Redis.AddCountIndex(c, rp.Oid, rp.Type, rp); err != nil {
|
|
log.Error("s.dao.Redis.AddCountIndex failed , RpID(%d), err(%v)", rp.RpID, err)
|
|
}
|
|
}
|
|
if ok, err = s.dao.Redis.ExpireIndex(c, rp.Oid, rp.Type, model.SortByLike); err == nil && ok {
|
|
rpts := make(map[int64]*reply.Report, 1)
|
|
if rpt, _ := s.dao.Report.Get(c, rp.Oid, rp.RpID); rpt != nil {
|
|
rpts[rp.RpID] = rpt
|
|
}
|
|
if err = s.dao.Redis.AddLikeIndex(c, rp.Oid, rp.Type, rpts, rp); err != nil {
|
|
log.Error("s.dao.Redis.AddLikeIndex failed , RpID(%d), err(%v)", rp.RpID, err)
|
|
}
|
|
}
|
|
} else {
|
|
if ok, err = s.dao.Redis.ExpireDialogIndex(c, rp.Dialog); err == nil && ok {
|
|
if err = s.dao.Redis.AddDialogIndex(c, rp.Dialog, []*model.Reply{rp}); err != nil {
|
|
log.Error("s.dao.Redis.AddDialogINdex Error (%v)", err)
|
|
}
|
|
}
|
|
if ok, err = s.dao.Redis.ExpireNewChildIndex(c, rp.Root); err == nil && ok {
|
|
if err = s.dao.Redis.AddNewChildIndex(c, rp.Root, rp); err != nil {
|
|
log.Error("s.dao.Redis.AddFloorIndexByRoot failed , rproot(%d), err(%v)", rp.Root, err)
|
|
}
|
|
}
|
|
if op == "re" || oldState == model.ReplyStateAudit {
|
|
if rootRp, err = s.getReplyCache(c, rp.Oid, rp.Root); err != nil {
|
|
log.Error("s.getReply failed , oid(%d), root(%d) err(%v)", rp.Oid, rp.Root, err)
|
|
} else if rootRp != nil {
|
|
rootRp.RCount++
|
|
if err = s.addReplyCache(c, rootRp); err != nil {
|
|
log.Error("s.addReplyCache oid(%d), rpid(%d) err(%v)", rootRp.Oid, rootRp.RpID, err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if err = s.addReplyCache(c, rp); err != nil {
|
|
log.Error("s.addReplyCache oid(%d), rpid(%d) err(%v)", rp.Oid, rp.RpID, err)
|
|
}
|
|
if oldState == model.ReplyStateAudit {
|
|
s.dao.Redis.DelAuditIndexs(c, rp)
|
|
}
|
|
// update reply count
|
|
s.upAcount(c, sub.Oid, sub.Type, sub.ACount, rp.CTime.Time())
|
|
if err = s.dao.Mc.AddSubject(c, sub); err != nil {
|
|
log.Error("s.dao.Mc.AddSubject failed , oid(%d) err(%v)", sub.Oid, err)
|
|
}
|
|
// admin log
|
|
if op == "re" {
|
|
s.adminLog(c, rp, adid, model.AdminIsNotReport, model.AdminOperRecover, "已恢复评论", remark)
|
|
|
|
} else if op == "pass" {
|
|
s.adminLog(c, rp, adid, model.AdminIsNotReport, model.AdminOperPass, "已通过评论", remark)
|
|
}
|
|
s.addSearchUp(c, oldState, rp, nil)
|
|
}
|
|
|
|
func (s *Service) tranRecover(c context.Context, rp *model.Reply, state int8, isRoot bool) error {
|
|
var (
|
|
err error
|
|
rootReply *model.Reply
|
|
count int
|
|
rows int64
|
|
tx *xsql.Tx
|
|
)
|
|
if tx, err = s.beginTran(c); err != nil {
|
|
return err
|
|
}
|
|
mtime := rp.MTime
|
|
if rp, err = s.dao.Reply.GetForUpdate(tx, rp.Oid, rp.RpID); err != nil || rp == nil {
|
|
tx.Rollback()
|
|
return fmt.Errorf("s.dao.Reply.GetForUpdate(%d,%d) error(%v) or is nil)", rp.Oid, rp.RpID, err)
|
|
}
|
|
if mtime != 0 {
|
|
rp.MTime = mtime
|
|
}
|
|
if rp.IsNormal() {
|
|
tx.Rollback()
|
|
return fmt.Errorf("reply(%d,%d) already is normal", rp.Oid, rp.RpID)
|
|
}
|
|
rows, err = s.dao.Reply.TxUpState(tx, rp.Oid, rp.RpID, state, rp.MTime.Time())
|
|
if err != nil || rows == 0 {
|
|
tx.Rollback()
|
|
return fmt.Errorf("TxUpState error(%v) or rows(%d)", err, rows)
|
|
}
|
|
if isRoot {
|
|
count = rp.RCount + 1
|
|
} else {
|
|
rootReply, err = s.dao.Reply.Get(c, rp.Oid, rp.Root)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
count = 1
|
|
}
|
|
if isRoot {
|
|
rows, err = s.dao.Subject.TxIncrRCount(tx, rp.Oid, rp.Type, rp.MTime.Time())
|
|
} else {
|
|
rows, err = s.dao.Reply.TxIncrRCount(tx, rp.Oid, rp.Root, rp.MTime.Time())
|
|
}
|
|
if err != nil || rows == 0 {
|
|
tx.Rollback()
|
|
return fmt.Errorf("TxIncrRCount error(%v) or rows(%d)", err, rows)
|
|
}
|
|
if isRoot || rootReply != nil && rootReply.IsNormal() {
|
|
rows, err = s.dao.Subject.TxIncrACount(tx, rp.Oid, rp.Type, count, rp.MTime.Time())
|
|
if err != nil || rows == 0 {
|
|
tx.Rollback()
|
|
return fmt.Errorf("TxIncrACount error(%v) or rows(%d)", err, rows)
|
|
}
|
|
}
|
|
return tx.Commit()
|
|
}
|
|
|
|
func (s *Service) tranDel(c context.Context, rp *model.Reply, state int8, sub *model.Subject, isRoot bool) error {
|
|
var (
|
|
count int
|
|
rows int64
|
|
rootReply *model.Reply
|
|
err error
|
|
tx *xsql.Tx
|
|
)
|
|
if tx, err = s.beginTran(c); err != nil {
|
|
return err
|
|
}
|
|
mtime := rp.MTime
|
|
if rp, err = s.dao.Reply.GetForUpdate(tx, rp.Oid, rp.RpID); err != nil || rp == nil {
|
|
tx.Rollback()
|
|
return fmt.Errorf("s.dao.Reply.GetForUpdate(%d,%d) error(%v) or is nil)", rp.Oid, rp.RpID, err)
|
|
}
|
|
if mtime != 0 {
|
|
rp.MTime = mtime
|
|
}
|
|
if rp.IsDeleted() || rp.AttrVal(reply.ReplyAttrAdminTop) == 1 {
|
|
tx.Rollback()
|
|
return fmt.Errorf("reply(%d,%d) already deleted", rp.Oid, rp.RpID)
|
|
}
|
|
rows, err = s.dao.Reply.TxUpState(tx, rp.Oid, rp.RpID, state, rp.MTime.Time())
|
|
if err != nil || rows == 0 {
|
|
tx.Rollback()
|
|
return fmt.Errorf("error(%v) or rows(%d)", err, rows)
|
|
}
|
|
if rp.IsNormal() {
|
|
if isRoot {
|
|
count = rp.RCount + 1
|
|
rows, err = s.dao.Subject.TxDecrACount(tx, rp.Oid, rp.Type, count, rp.MTime.Time())
|
|
if err != nil || rows == 0 {
|
|
tx.Rollback()
|
|
return fmt.Errorf("error(%v) or rows(%d)", err, rows)
|
|
}
|
|
rows, err = s.dao.Subject.TxDecrCount(tx, rp.Oid, rp.Type, rp.MTime.Time())
|
|
if err != nil || rows == 0 {
|
|
tx.Rollback()
|
|
return fmt.Errorf("SubjectTxDecrCount error(%v) or rows(%d)", err, rows)
|
|
}
|
|
} else {
|
|
if rootReply, err = s.dao.Reply.GetForUpdate(tx, rp.Oid, rp.Root); err != nil {
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
if rootReply != nil {
|
|
if rootReply.IsNormal() {
|
|
rows, err = s.dao.Subject.TxDecrACount(tx, rp.Oid, rp.Type, 1, rp.MTime.Time())
|
|
if err != nil || rows == 0 {
|
|
tx.Rollback()
|
|
return fmt.Errorf("error(%v) or rows(%d)", err, rows)
|
|
}
|
|
}
|
|
rows, err = s.dao.Reply.TxDecrCount(tx, rp.Oid, rp.Root, rp.MTime.Time())
|
|
if err != nil || rows == 0 {
|
|
tx.Rollback()
|
|
return fmt.Errorf("ReplyTxDecrCount error(%v) or rows(%d)", err, rows)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if rp.AttrVal(model.ReplyAttrUpperTop) == 1 {
|
|
rp.AttrSet(0, model.ReplyAttrUpperTop)
|
|
sub.AttrSet(0, model.SubAttrUpperTop)
|
|
sub.TopSet(0, model.SubAttrUpperTop, 0)
|
|
if rows, err = s.dao.Subject.TxUpMeta(tx, sub.Oid, sub.Type, sub.Meta, rp.MTime.Time()); err != nil || rows == 0 {
|
|
tx.Rollback()
|
|
log.Error("dao.TxUpMeta(oid:%d,tp:%d) err(%v) rows(%d)", sub.Oid, sub.Type, err, rows)
|
|
return fmt.Errorf("dao.TxUpMeta(oid:%d,tp:%d) err(%v) rows(%d)", sub.Oid, sub.Type, err, rows)
|
|
}
|
|
if rows, err = s.dao.Subject.TxUpAttr(tx, sub.Oid, sub.Type, sub.Attr, rp.MTime.Time()); err != nil || rows == 0 {
|
|
tx.Rollback()
|
|
return fmt.Errorf("dao.Upattr(oid:%d,tp:%d) err(%v) rows(%d)", sub.Oid, sub.Type, err, rows)
|
|
}
|
|
//rp.State = model.ReplyStateTop
|
|
if rows, err = s.dao.Reply.TxUpAttr(tx, rp.Oid, rp.RpID, rp.Attr, rp.MTime.Time()); err != nil || rows == 0 {
|
|
tx.Rollback()
|
|
return fmt.Errorf("dao.Reply.UpState(%v, %d) error(%v) or rows(%d)", rp, rp.State, err, rows)
|
|
}
|
|
}
|
|
if rp.State == model.ReplyStateMonitor || rp.State == model.ReplyStateAudit {
|
|
if _, err = s.dao.Subject.TxDecrMCount(tx, rp.Oid, rp.Type, rp.MTime.Time()); err != nil {
|
|
tx.Rollback()
|
|
log.Error("dao.Reply.TxDecrMCount(%v) error(%v)", rp, err)
|
|
return fmt.Errorf("dao.Reply.TxDecrMCount error(%v)", err)
|
|
}
|
|
}
|
|
return tx.Commit()
|
|
}
|
|
|
|
func (s *Service) eraseAuditIndex(c context.Context, rp *model.Reply) (err error) {
|
|
var rs []*model.Reply
|
|
if rp.Root == 0 && rp.Parent == 0 {
|
|
if rs, err = s.dao.Reply.GetsByRoot(c, rp.Oid, rp.RpID, rp.Type, model.ReplyStateAudit); err != nil {
|
|
return
|
|
}
|
|
}
|
|
if err = s.dao.Redis.DelAuditIndexs(c, append(rs, rp)...); err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) addReplyCache(c context.Context, rp *model.Reply) (err error) {
|
|
var isRoot = rp.Root == 0 && rp.Parent == 0
|
|
if err = s.dao.Mc.AddReply(c, rp); err != nil {
|
|
log.Error("s.dao.Mc.AddReply(%d,%d,%d) error(%v)", rp.Oid, rp.RpID, rp.Type, err)
|
|
}
|
|
if isRoot && rp.IsTop() {
|
|
if err = s.dao.Mc.AddTop(c, rp); err != nil {
|
|
log.Error("s.dao.Mc.AddTop(%d,%d,%d) error(%v)", rp.Oid, rp.RpID, rp.Type, err)
|
|
}
|
|
}
|
|
return
|
|
}
|