443 lines
12 KiB
Go
443 lines
12 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"time"
|
||
|
||
"go-common/app/interface/main/reply/conf"
|
||
"go-common/app/interface/main/reply/model/reply"
|
||
"go-common/library/ecode"
|
||
"go-common/library/log"
|
||
"go-common/library/net/metadata"
|
||
"go-common/library/queue/databus/report"
|
||
xtime "go-common/library/time"
|
||
)
|
||
|
||
// AdminGetSubject get subject state
|
||
func (s *Service) AdminGetSubject(c context.Context, oid int64, tp int8) (sub *reply.Subject, err error) {
|
||
if !reply.LegalSubjectType(tp) {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
if sub, err = s.dao.Subject.Get(c, oid, tp); err != nil {
|
||
log.Error("s.dao.Subject.Get(%d,%d) error(%v)", oid, tp, err)
|
||
return
|
||
}
|
||
if sub == nil {
|
||
err = ecode.NothingFound
|
||
}
|
||
return
|
||
}
|
||
|
||
// AdminSubRegist register subject of new archive
|
||
func (s *Service) AdminSubRegist(c context.Context, oid, mid int64, tp, state int8, appkey string) (err error) {
|
||
var has bool
|
||
tps, ok := conf.Conf.AppkeyType[appkey]
|
||
if !ok || len(tps) == 0 {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
if tp != 0 {
|
||
for _, t := range tps {
|
||
if t == tp {
|
||
has = true
|
||
break
|
||
}
|
||
}
|
||
} else {
|
||
has = true
|
||
tp = tps[0]
|
||
}
|
||
if !has {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
now := time.Now()
|
||
sub := &reply.Subject{
|
||
Oid: oid,
|
||
Type: tp,
|
||
Mid: mid,
|
||
State: state,
|
||
CTime: xtime.Time(now.Unix()),
|
||
MTime: xtime.Time(now.Unix()),
|
||
}
|
||
if sub.ID, err = s.dao.Subject.Insert(c, sub); err != nil {
|
||
log.Error("s.dao.Subject.Insert(%v) error(%v)", sub, err)
|
||
}
|
||
s.cache.Do(c, func(ctx context.Context) {
|
||
if err = s.dao.Mc.DeleteSubject(ctx, oid, tp); err != nil {
|
||
log.Error("s.dao.Mc.DeleteSubject(%d, %d) state:%d error(%v)", oid, tp, state, err)
|
||
}
|
||
})
|
||
return
|
||
}
|
||
|
||
// AdminSubjectState change subject state by admin.
|
||
func (s *Service) AdminSubjectState(c context.Context, adid, oid, mid int64, tp, state int8, remark string) (err error) {
|
||
if !reply.LegalSubjectType(tp) {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
now := time.Now()
|
||
if err = reply.CheckSubState(state); err != nil {
|
||
log.Error("checkstate err(%v)", err)
|
||
return
|
||
}
|
||
if mid <= 0 {
|
||
var sub *reply.Subject
|
||
sub, err = s.dao.Subject.Get(c, oid, tp)
|
||
if err != nil {
|
||
log.Error("s.dao.subject (%d,%d)error(%v)", oid, tp, err)
|
||
return
|
||
}
|
||
if sub == nil {
|
||
err = ecode.NothingFound
|
||
return
|
||
}
|
||
mid = sub.Mid
|
||
}
|
||
if _, err = s.setSubject(c, oid, tp, state, mid); err != nil {
|
||
log.Error("s.addSubject(%d, %d, %d, %d) error(%v)", oid, tp, state, mid, err)
|
||
return
|
||
}
|
||
s.cache.Do(c, func(ctx context.Context) {
|
||
if err = s.dao.Mc.DeleteSubject(ctx, oid, tp); err != nil {
|
||
log.Error("s.dao.Mc.DeleteSubject(%d, %d) state:%d error(%v)", oid, tp, state, err)
|
||
}
|
||
})
|
||
s.dao.Admin.Insert(c, adid, oid, 0, tp, fmt.Sprintf("修改主题状态为: %d", state), remark, reply.AdminIsNotNew, reply.AdminIsNotReport, reply.AdminOperSubState, now)
|
||
return
|
||
}
|
||
|
||
// AdminSubjectMid set the subject mid info.
|
||
func (s Service) AdminSubjectMid(c context.Context, adid, mid, oid int64, tp int8, remark string) (err error) {
|
||
// check subject
|
||
if !reply.LegalSubjectType(tp) {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
now := time.Now()
|
||
if _, err = s.dao.Subject.UpMid(c, mid, oid, tp, now); err != nil {
|
||
log.Error("replySubDao.UpMid(%d, %d, %d) error(%v)", mid, oid, tp, err)
|
||
return
|
||
}
|
||
s.cache.Do(c, func(ctx context.Context) {
|
||
if err = s.dao.Mc.DeleteSubject(ctx, oid, tp); err != nil {
|
||
log.Error("s.dao.Mc.DeleteSubject(%d, %d) mid:%d error(%v)", oid, tp, mid, err)
|
||
}
|
||
})
|
||
s.dao.Admin.Insert(c, adid, oid, 0, tp, fmt.Sprintf("修改主题mid为: %d", mid), remark, reply.AdminIsNotNew, reply.AdminIsNotReport, reply.AdminOperSubMid, now)
|
||
return
|
||
}
|
||
|
||
// Delete delete reply by upper or self.
|
||
func (s *Service) Delete(c context.Context, mid, oid, rpID int64, tp int8, ak, ck, platform string, build int64, buvid string) (err error) {
|
||
// check subject
|
||
if !reply.LegalSubjectType(tp) {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
rp, _ := s.reply(c, mid, oid, rpID, tp)
|
||
if rp == nil {
|
||
return
|
||
}
|
||
subject, err := s.getSubject(c, oid, tp)
|
||
if err != nil {
|
||
return
|
||
}
|
||
var (
|
||
assist, operation bool
|
||
state = reply.ReplyStateUserDel
|
||
)
|
||
// check permission，only upper and self can del
|
||
if !s.IsWhiteAid(subject.Oid, subject.Type) {
|
||
assist, operation = s.CheckAssist(c, subject.Mid, mid)
|
||
if !operation {
|
||
assist = false
|
||
}
|
||
if assist {
|
||
state = reply.ReplyStateAssistDel
|
||
}
|
||
}
|
||
if subject.Mid == mid {
|
||
state = reply.ReplyStateUpDel
|
||
}
|
||
if subject.Mid == mid || mid == rp.Mid || assist {
|
||
if rp.IsDeleted() {
|
||
s.dao.Redis.DelIndex(c, rp)
|
||
err = ecode.ReplyDeleted
|
||
return
|
||
} else if rp.AttrVal(reply.ReplyAttrAdminTop) == 1 {
|
||
err = ecode.ReplyDelTopForbidden
|
||
return
|
||
}
|
||
} else {
|
||
err = ecode.AccessDenied
|
||
return
|
||
}
|
||
s.dao.Databus.Delete(c, mid, oid, rpID, time.Now().Unix(), tp, assist)
|
||
remoteIP := metadata.String(c, metadata.RemoteIP)
|
||
report.User(&report.UserInfo{
|
||
Mid: rp.Mid,
|
||
Platform: platform,
|
||
Build: build,
|
||
Buvid: buvid,
|
||
Business: 41,
|
||
Type: int(rp.Type),
|
||
Oid: rp.Oid,
|
||
Action: reply.ReportReplyDel,
|
||
Ctime: time.Now(),
|
||
IP: remoteIP,
|
||
Index: []interface{}{
|
||
rp.RpID,
|
||
rp.State,
|
||
state,
|
||
},
|
||
})
|
||
return
|
||
}
|
||
|
||
// AdminEdit edit reply content by admin.
|
||
func (s *Service) AdminEdit(c context.Context, adid, oid, rpID int64, tp int8, msg, remark string) (err error) {
|
||
now := time.Now()
|
||
var rp *reply.Reply
|
||
// check subject
|
||
if !reply.LegalSubjectType(tp) {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
if rp, err = s.reply(c, 0, oid, rpID, tp); err != nil {
|
||
return
|
||
}
|
||
if rp.IsDeleted() {
|
||
err = ecode.ReplyDeleted
|
||
return
|
||
}
|
||
if _, err = s.dao.Content.UpMessage(c, oid, rpID, msg, now); err != nil {
|
||
log.Error("s.content.UpMessage(%d, %d, %s, %v), err is (%v)", oid, rpID, msg, now, err)
|
||
return
|
||
}
|
||
if err = s.dao.Mc.DeleteReply(c, rpID); err != nil {
|
||
log.Error("s.dao.Mc.DeleteReply(%d, %d, %s, %v), err is (%v)", oid, rpID, msg, now, err)
|
||
}
|
||
// admin log
|
||
if _, err = s.dao.Admin.UpIsNotNew(c, rpID, now); err != nil {
|
||
log.Error("s.admin.UpIsNotNew(%d, %d, %s, %v), err is (%v)", oid, rpID, msg, now, err)
|
||
}
|
||
if _, err = s.dao.Admin.Insert(c, adid, oid, rpID, tp, "已修改评论内容", remark, reply.AdminIsNew, reply.AdminIsNotReport, reply.AdminOperEdit, now); err != nil {
|
||
log.Error("s.admin.Insert(%d, %d, %s, %v), err is (%v)", oid, rpID, msg, now, err)
|
||
}
|
||
// dao.Kafka
|
||
s.dao.Databus.AdminEdit(c, oid, rpID, tp)
|
||
return
|
||
}
|
||
|
||
// AdminDelete delete reply by admin.
|
||
func (s *Service) AdminDelete(c context.Context, adid, oid, rpID, ftime int64, tp int8, moral int, notify bool, adname, remark string, reason, freason int8) (err error) {
|
||
// check subject
|
||
now := time.Now()
|
||
if !reply.LegalSubjectType(tp) {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
rp, _ := s.reply(c, 0, oid, rpID, tp)
|
||
if rp == nil {
|
||
log.Error("s.Reply(oid:%v,tp:%v,:rpID:%v)", oid, tp, rpID, err)
|
||
return
|
||
} else if rp.AttrVal(reply.ReplyAttrAdminTop) == 1 {
|
||
err = ecode.ReplyDelTopForbidden
|
||
return
|
||
}
|
||
s.dao.Databus.AdminDelete(c, adid, oid, rpID, ftime, moral, notify, adname, remark, now.Unix(), tp, reason, freason)
|
||
return
|
||
}
|
||
|
||
// AdminPass recover reply by admin.
|
||
func (s *Service) AdminPass(c context.Context, adid, oid, rpID int64, tp int8, remark string) (err error) {
|
||
// check subject
|
||
now := time.Now()
|
||
if !reply.LegalSubjectType(tp) {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
s.dao.Databus.AdminPass(c, adid, oid, rpID, remark, now.Unix(), tp)
|
||
return
|
||
}
|
||
|
||
// AdminRecover recover reply by admin.
|
||
func (s *Service) AdminRecover(c context.Context, adid, oid, rpID int64, tp int8, remark string) (err error) {
|
||
// check subject
|
||
now := time.Now()
|
||
if !reply.LegalSubjectType(tp) {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
s.dao.Databus.AdminRecover(c, adid, oid, rpID, remark, now.Unix(), tp)
|
||
return
|
||
}
|
||
|
||
// AdminDeleteByReport delete report reply by admin.
|
||
func (s *Service) AdminDeleteByReport(c context.Context, adid, oid, rpID, ftime int64, tp int8, moral int, notify bool, adname, remark string, audit int8, reason int8, content string, freason int8) (err error) {
|
||
var (
|
||
rp *reply.Reply
|
||
now = time.Now()
|
||
)
|
||
// check subject
|
||
if !reply.LegalSubjectType(tp) {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
rpt, err := s.dao.Report.Get(c, oid, rpID)
|
||
if err != nil {
|
||
log.Error("s.report.GetReport(%d, %d) error(%v)", oid, rpID, err)
|
||
return
|
||
}
|
||
if rpt == nil {
|
||
err = ecode.ReplyReportNotExist
|
||
return
|
||
}
|
||
if rp, err = s.dao.Reply.Get(c, oid, rpID); err != nil {
|
||
log.Error("s.reply.GetReply(%d, %d) error(%v)", oid, rpID, err)
|
||
return
|
||
} else if rp == nil {
|
||
err = ecode.ReplyNotExist
|
||
return
|
||
} else if rp.AttrVal(reply.ReplyAttrAdminTop) == 1 {
|
||
err = ecode.ReplyDelTopForbidden
|
||
return
|
||
}
|
||
s.dao.Databus.AdminDeleteByReport(c, adid, oid, rpID, rpt.Mid, ftime, moral, notify, adname, remark, now.Unix(), tp, audit, reason, content, freason)
|
||
return
|
||
}
|
||
|
||
// AdminReportStateSet set report state by admin.
|
||
func (s *Service) AdminReportStateSet(c context.Context, adid, oid, rpID int64, tp, state int8) (err error) {
|
||
now := time.Now()
|
||
// check subject
|
||
if !reply.LegalSubjectType(tp) {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
rpt, err := s.dao.Report.Get(c, oid, rpID)
|
||
if err != nil {
|
||
log.Error("s.report.GetReport(%d, %d) met error (%v)", oid, rpID, err)
|
||
return
|
||
}
|
||
if rpt == nil {
|
||
err = ecode.ReplyReportNotExist
|
||
return
|
||
}
|
||
// dao.Kafka
|
||
s.dao.Databus.AdminStateSet(c, adid, oid, rpID, now.Unix(), tp, state)
|
||
return
|
||
}
|
||
|
||
// AdminReportTransfer transfer report by admin.
|
||
func (s *Service) AdminReportTransfer(c context.Context, adid, oid, rpID int64, tp, audit int8) (err error) {
|
||
now := time.Now()
|
||
// check subject
|
||
if !reply.LegalSubjectType(tp) {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
rpt, err := s.dao.Report.Get(c, oid, rpID)
|
||
if err != nil {
|
||
log.Error("s.report.GetReport(%d, %d) met error (%v)", oid, rpID, err)
|
||
return
|
||
}
|
||
if rpt == nil {
|
||
err = ecode.ReplyReportNotExist
|
||
return
|
||
}
|
||
// dao.Kafka
|
||
s.dao.Databus.AdminTransfer(c, adid, oid, rpID, now.Unix(), tp, audit)
|
||
return
|
||
}
|
||
|
||
// AdminReportIgnore ignore report by admin.
|
||
func (s *Service) AdminReportIgnore(c context.Context, adid, oid, rpID int64, tp, audit int8, remark string) (err error) {
|
||
now := time.Now()
|
||
// check subject
|
||
if !reply.LegalSubjectType(tp) {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
rpt, err := s.dao.Report.Get(c, oid, rpID)
|
||
if err != nil {
|
||
log.Error("s.report.GetReport(%d, %d) met error (%v)", oid, rpID, err)
|
||
return
|
||
}
|
||
if rpt == nil {
|
||
err = ecode.ReplyReportNotExist
|
||
return
|
||
}
|
||
// dao.Kafka
|
||
s.dao.Databus.AdminIgnore(c, adid, oid, rpID, now.Unix(), tp, audit)
|
||
return
|
||
}
|
||
|
||
// AdminAddTop add top reply by admin
|
||
func (s *Service) AdminAddTop(c context.Context, adid, oid, rpID int64, tp, act int8) (err error) {
|
||
var (
|
||
ts = time.Now().Unix()
|
||
r *reply.Reply
|
||
)
|
||
if !reply.LegalSubjectType(tp) {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
sub, err := s.Subject(c, oid, tp)
|
||
if err != nil {
|
||
log.Error("s.Subject(oid %v) err(%v)", oid, err)
|
||
return
|
||
}
|
||
if r, err = s.GetTop(c, sub, oid, tp, reply.ReplyAttrAdminTop); err != nil {
|
||
log.Error("s.GetTop(%d,%d) err(%v)", oid, tp, err)
|
||
return
|
||
}
|
||
if r != nil && act == 1 {
|
||
log.Warn("oid(%d) type(%d) already have top ", oid, tp)
|
||
err = ecode.ReplyHaveTop
|
||
return
|
||
}
|
||
if r == nil && act == 0 {
|
||
log.Warn("oid(%d) type(%d) do not have top ", oid, tp)
|
||
err = ecode.ReplyNotExist
|
||
return
|
||
}
|
||
// TODO: only need reply,no not need content and user info
|
||
if r, err = s.reply(c, 0, oid, rpID, tp); err != nil {
|
||
log.Error("s.GetReply err (%v)", err)
|
||
return
|
||
}
|
||
if r == nil {
|
||
log.Warn("oid(%d) type(%d) rpID(%d) do not exist ", oid, tp, rpID)
|
||
err = ecode.ReplyNotExist
|
||
return
|
||
}
|
||
if r.AttrVal(reply.ReplyAttrUpperTop) == 1 {
|
||
err = ecode.ReplyHaveTop
|
||
return
|
||
}
|
||
if r.Root != 0 {
|
||
log.Warn("oir(%d) type(%d) rpID(%d) not root reply", oid, tp, rpID)
|
||
err = ecode.ReplyNotRootReply
|
||
return
|
||
}
|
||
s.dao.Databus.AdminAddTop(c, adid, oid, rpID, ts, act, tp)
|
||
return
|
||
}
|
||
|
||
// AdminReportRecover recover report by admin.
|
||
func (s *Service) AdminReportRecover(c context.Context, adid, oid, rpID int64, tp, audit int8, remark string) (err error) {
|
||
// check subject
|
||
now := time.Now()
|
||
if !reply.LegalSubjectType(tp) {
|
||
err = ecode.ReplyIllegalSubType
|
||
return
|
||
}
|
||
s.dao.Databus.AdminReportRecover(c, adid, oid, rpID, remark, now.Unix(), tp, audit)
|
||
return
|
||
}
|