openbilibili/app/interface/main/dm2/service/dmpost.go

package service

import (
	"context"
	"encoding/json"
	"fmt"
	"regexp"
	"strconv"
	"strings"
	"time"

	"go-common/app/interface/main/dm2/model"
	"go-common/app/interface/main/dm2/model/oplog"
	account "go-common/app/service/main/account/api"
	"go-common/app/service/main/archive/api"
	arcMdl "go-common/app/service/main/archive/model/archive"
	figureMdl "go-common/app/service/main/figure/model"
	filterMdl "go-common/app/service/main/filter/api/grpc/v1"
	locmdl "go-common/app/service/main/location/model"
	spyMdl "go-common/app/service/main/spy/model"
	ugcPayMdl "go-common/app/service/main/ugcpay/api/grpc/v1"
	seasonMbl "go-common/app/service/openplatform/pgc-season/api/grpc/season/v1"
	"go-common/library/ecode"
	"go-common/library/log"
	"go-common/library/net/metadata"
)

var (
	msgRegex = regexp.MustCompile(`^(\s|\xE3\x80\x80)*$`) // 全文仅空格

	_dateFormat = "20060102"
)

//Post dm post
func (s *Service) Post(c context.Context, dm *model.DM, aid, rnd int64) (err error) {
	// 验证主题是否存在
	sub, err := s.subject(c, dm.Type, dm.Oid)
	if err != nil {
		return
	}
	if sub.State == model.SubStateClosed {
		err = ecode.DMForbidPost
		return
	}
	if sub.Maxlimit == 0 {
		return
	}
	// 验证海外用户
	if err = s.checkOverseasUser(c); err != nil {
		return
	}
	// 验证账号信息
	myinfo, err := s.checkAccountInfo(c, dm.Mid)
	if err != nil {
		return
	}
	// 验证弹幕内容
	if err = s.checkMsg(c, dm, myinfo); err != nil {
		return
	}
	// 验证弹幕progress
	duration, err := s.videoDuration(c, aid, dm.Oid)
	if err != nil {
		return
	}
	if duration > 0 && int64(dm.Progress) > duration {
		return ecode.DMProgressTooBig
	}
	// 验证稿件信息
	arc, err := s.checkArchiveInfo(c, aid, dm.Oid, myinfo.GetRank(), dm.Content.Mode)
	if err != nil {
		return
	}
	if sub.Mid != dm.Mid && arc.Rights.UGCPay == arcMdl.AttrYes {
		if err = s.archiveUgcPay(c, dm.Mid, aid); err != nil {
			return
		}
	}
	// 验证弹幕发送速率
	if err = s.checkPubRate(c, dm, sub.Mid, rnd, myinfo.GetRank()); err != nil {
		return
	}
	// 判定用户发送速率
	if err = s.checkRateLimit(c, myinfo.GetRank(), dm.Mid); err != nil {
		return
	}
	// 验证弹幕颜色
	if err = s.checkMsgColor(sub.Mid, myinfo, dm); err != nil {
		return
	}
	// 判定弹幕字体大小
	if err = s.checkFontsize(dm, sub.Mid, myinfo.GetRank()); err != nil {
		return
	}
	// 验证mode 1、4、5、6
	if err = s.checkNormalMode(sub.Mid, myinfo, dm); err != nil {
		return
	}
	// 验证mode 7发送权限
	if err = s.checkAdvanceMode(c, dm, sub.Mid, myinfo); err != nil {
		return
	}
	// 验证特殊弹幕池(pool=1 pool=2)发送权限
	if err = s.checkSpecialPool(c, dm, sub.Mid, myinfo); err != nil {
		return
	}
	// 生成弹幕id
	if err = s.genDMID(c, dm); err != nil {
		return
	}
	// 弹幕屏蔽词过滤
	if err = s.checkFilterService(c, dm, arc); err != nil {
		return
	}
	// 检查up的全局屏蔽词
	if err = s.checkUpFilter(c, dm, sub.Mid, myinfo.GetRank()); err != nil {
		return
	}
	// 弹幕的先审后发和先发后审
	if err = s.checkMonitor(c, sub, dm); err != nil {
		return
	}
	// 垃圾弹幕过滤
	if err = s.checkUnusualAction(c, dm, myinfo); err != nil {
		return
	}
	// bnj专用 黑名单过滤
	s.checkShield(c, aid, dm)
	// 发消息给job异步落库
	if err = s.asyncAddDM(dm, arc.Aid, arc.TypeID); err != nil {
		return
	}
	remark := fmt.Sprintf("新增弹幕,ip:%s,port:%s", metadata.String(c, metadata.RemoteIP), metadata.String(c, metadata.RemotePort))
	s.OpLog(c, dm.Oid, dm.Mid, time.Now().Add(time.Second).Unix(), 1, []int64{dm.ID}, "status", "", strconv.FormatInt(int64(dm.State), 10), remark, oplog.SourcePlayer, oplog.OperatorMember)
	// 弹幕行为日志
	s.dao.ReportDmLog(c, dm)
	// 弹幕广播
	select {
	case s.broadcastChan <- &broadcast{Aid: arc.Aid, Rnd: rnd, DM: dm}:
	default:
		log.Error("broadcast channel is full")
	}
	return
}

// checkUnusualAction check unusual post dm
func (s *Service) checkUnusualAction(c context.Context, dm *model.DM, accInfo *account.Profile) (err error) {
	var (
		ip             = metadata.String(c, metadata.RemoteIP)
		userScore      *spyMdl.UserScore
		figureWithRank *figureMdl.FigureWithRank
		dmDailyLimit   *model.DailyLimiter
	)

	if !s.garbageDanmu {
		return
	}
	if userScore, err = s.spyRPC.UserScore(c, &spyMdl.ArgUserScore{
		Mid: accInfo.GetMid(),
		IP:  ip,
	}); err != nil {
		// dragrade spy service
		err = nil
		return
	}
	if figureWithRank, err = s.figureRPC.UserFigure(c, &figureMdl.ArgUserFigure{
		Mid: accInfo.GetMid(),
	}); err != nil {
		if ecode.Cause(err).Code() != ecode.FigureNotFound.Code() {
			log.Error("checkUnusualAction.UserFigure(mid:%v) error(%v)", accInfo.GetMid(), err)
			return
		}
		err = nil
		return
	}
	if accInfo.GetMid() > 50000000 && accInfo.GetLevel() <= 2 && figureWithRank.Percentage > 40 && userScore.Score < 90 {
		if dmDailyLimit, err = s.dao.GetDmDailyLimitCache(c, accInfo.GetMid()); err != nil {
			return
		}
		now := time.Now().Format(_dateFormat)
		if dmDailyLimit == nil || now > dmDailyLimit.Date {
			dmDailyLimit = &model.DailyLimiter{
				Date:  time.Now().Format(_dateFormat),
				Count: 0,
			}
		}
		dmDailyLimit.Count++
		if dmDailyLimit.Count > 5 {
			dm.State = model.StateDelete
			s.OpLog(c, dm.Oid, dm.Mid, time.Now().Unix(), 1, []int64{dm.ID}, "status", "", strconv.FormatInt(int64(dm.State), 10), "垃圾弹幕发送", oplog.SourcePlayer, oplog.OperatorMember)
			s.dao.ReportDmGarbageLog(c, dm)
		}
		if err = s.dao.SetDmDailyLimitCache(c, accInfo.GetMid(), dmDailyLimit); err != nil {
			return
		}
		return
	}
	return
}

func (s *Service) checkFontsize(dm *model.DM, upid int64, rank int32) (err error) {
	if !s.isSuperUser(rank) && dm.Content.Mode != model.ModeSpecial {
		if dm.Content.FontSize != 18 && dm.Content.FontSize != 25 {
			dm.Content.FontSize = 25
		}
	}
	return
}

func (s *Service) checkMsgColor(upid int64, profile *account.Profile, dm *model.DM) (err error) {
	if s.isSuperUser(profile.GetRank()) || dm.Mid == upid {
		return
	}
	if profile.GetLevel() <= 1 && dm.Content.Color != 0xffffff {
		err = ecode.DMMsgNoColorPerm
	}
	return
}

// 验证mode 1、4、5、6
func (s *Service) checkNormalMode(upid int64, profile *account.Profile, dm *model.DM) (err error) {
	if s.isSuperUser(profile.GetRank()) {
		return
	}
	switch dm.Content.Mode {
	case 1:
		if profile.GetLevel() < 1 && upid != dm.Mid {
			err = ecode.DMMsgNoPubPerm
		}
	case 4:
		if profile.GetLevel() < 3 && upid != dm.Mid {
			err = ecode.DMMsgNoPubBottomPerm
		}
	case 5:
		if profile.GetLevel() < 3 && upid != dm.Mid {
			err = ecode.DMMsgNoPubTopPerm
		}
	case 6:
		err = ecode.DMMsgNoPubAdvancePerm
	}
	return
}

// 验证 mode 7
func (s *Service) checkAdvanceMode(c context.Context, dm *model.DM, upid int64, profile *account.Profile) (err error) {
	if dm.Content.Mode != 7 || dm.Mid == upid || s.isSuperUser(profile.GetRank()) {
		return
	}
	if profile.GetLevel() <= 1 {
		err = ecode.DMMsgNoPubStylePerm
		return
	}
	var adv *model.AdvanceCmt
	if adv, err = s.advanceComment(c, dm.Oid, dm.Mid, "sp"); err != nil {
		return
	}
	if adv.Type != "buy" && adv.Type != "accept" {
		err = ecode.DMMsgNoPubStylePerm
	}
	return
}

// 验证 pool 1、2
func (s *Service) checkSpecialPool(c context.Context, dm *model.DM, upid int64, profile *account.Profile) (err error) {
	if (dm.Pool != 1 && dm.Pool != 2) || dm.Mid == upid || s.isSuperUser(profile.Rank) {
		return
	}
	if dm.Pool == model.PoolSubtitle {
		dm.Pool = model.PoolNormal
		log.Warn("force change(%+v) pool to normal", dm)
		return
	}
	if profile.Level <= 1 {
		err = ecode.DMMsgNoPubStylePerm
		return
	}
	var adv *model.AdvanceCmt
	if dm.Pool == model.PoolSpecial {
		if adv, err = s.advanceComment(c, dm.Oid, dm.Mid, "advance"); err != nil {
			return
		}
		if adv.Type != "buy" && adv.Type != "accept" {
			err = ecode.DMMsgNoPubStylePerm
			return
		}
		if profile.Rank <= 10000 {
			err = ecode.DMMsgNoPubStylePerm
		}
	}
	return
}

func (s *Service) checkFilterService(c context.Context, dm *model.DM, arc *api.Arc) (err error) {
	if dm.Content.Mode == 7 || dm.Content.Mode == 8 || dm.Content.Mode == 9 {
		return
	}
	var (
		sid         int32
		pid         int64
		rid         = arc.TypeID
		keys        []string
		filterReply *filterMdl.FilterReply
		seasonReply *seasonMbl.CardsInfoReply
	)
	if v, ok := s.arcTypes[int16(rid)]; ok {
		pid = int64(v)
	}
	if arc.AttrVal(arcMdl.AttrBitIsBangumi) == arcMdl.AttrYes {
		if seasonReply, err = s.seasonRPC.CardsByAids(c, &seasonMbl.SeasonAidReq{
			Aids: []int32{int32(arc.Aid)},
		}); err != nil || seasonReply == nil {
			log.Error("s.seasonRPC.CardsByAids(%d) error(%v)", arc.Aid, err) // NOTE ignore error and continue
		} else if seasonInfo, ok := seasonReply.Cards[int32(arc.Aid)]; !ok {
			log.Error("seasonReply.Cards(%d) don't exist", arc.Aid)
		} else {
			sid = seasonInfo.SeasonId
		}
	}
	if sid > 0 {
		keys = append(keys, fmt.Sprintf("season:%d", sid))
	}
	keys = append(keys, fmt.Sprintf("typeid:%d", rid))
	keys = append(keys, fmt.Sprintf("typeid:%d", pid))
	keys = append(keys, fmt.Sprintf("cid:%d", dm.Oid))
	keys = append(keys, fmt.Sprintf("aid:%d", arc.Aid))
	if filterReply, err = s.filterRPC.Filter(c, &filterMdl.FilterReq{
		Area:    "danmu",
		Message: dm.Content.Msg,
		TypeId:  int64(rid),
		Id:      dm.ID,
		Oid:     dm.Oid,
		Mid:     dm.Mid,
		Keys:    keys,
	}); err != nil {
		log.Error("checkFilterService(dm:%+v),err(%v)", dm, err)
		return
	}
	if filterReply.Level > 0 || filterReply.Limit == model.SpamBlack || filterReply.Limit == model.SpamOverflow {
		dm.State = model.StateFilter
		log.Info("filter service delete(dmid:%d,data:+%v)", dm.ID, filterReply)
		remark := filterReply.Result
		if filterReply.Limit == model.SpamBlack {
			remark = "命中反垃圾黑名单"
		}
		if filterReply.Limit == model.SpamOverflow {
			remark = "超过反垃圾限制次数"
		}
		s.OpLog(c, dm.Oid, dm.Mid, time.Now().Unix(), 1, []int64{dm.ID}, "status", "", strconv.FormatInt(int64(dm.State), 10), remark, oplog.SourcePlayer, oplog.OperatorMember)
		return
	}
	if filterReply.Ai != nil && len(filterReply.Ai.Scores) > 0 && filterReply.Ai.Scores[0] > filterReply.Ai.Threshold {
		dm.State = model.StateAiDelete
		s.OpLog(c, dm.Oid, dm.Mid, time.Now().Unix(), 1, []int64{dm.ID}, "status", "", strconv.FormatInt(int64(dm.State), 10), "ai 反垃圾屏蔽", oplog.SourcePlayer, oplog.OperatorMember)
		return
	}
	return
}

// checkUpFilter up主屏蔽词过滤
func (s *Service) checkUpFilter(c context.Context, dm *model.DM, upid int64, rank int32) (err error) {
	// 命中屏蔽词系统 或者 mode 8 9 后则不再进行校验up主屏蔽词
	if dm.State == model.StateFilter || dm.Content.Mode == model.ModeCode || dm.Content.Mode == model.ModeBAS {
		return
	}
	var (
		msg                  string
		fltModes             []int32
		texts, regexs, users []string
	)
	// up主全局屏蔽词
	filters, err := s.UpFilters(c, upid)
	if err != nil {
		return
	}
	for _, f := range filters {
		switch f.Type {
		case 0: // 文本类型
			texts = append(texts, f.Filter)
		case 1: // 正则类型
			f.Filter = strings.Replace(f.Filter, "/", "\\/", -1)
			regexs = append(regexs, f.Filter)
		case 2: // 用户黑名单
			f.Filter = strings.ToLower(f.Filter)
			users = append(users, f.Filter)
		case 4, 5, 6, 7: // 4:down,5:up,6:reverse,7:special
			fltModes = append(fltModes, int32(f.Type))
		}
	}
	// check content filter
	if dm.Content.Mode == model.ModeSpecial {
		strs := strings.Split(dm.Content.Msg, ",")
		if len(strs) < 4 || len(strs[4]) < 2 {
			log.Error("s.checkUpFilter(%s) error(spec content format err)", dm)
			return
		}
		msg = strs[4][1 : len(strs[4])-1]
	} else {
		msg = dm.Content.Msg
	}
	// 验证up设置的mode屏蔽
	for _, mode := range fltModes {
		if mode == dm.Content.Mode {
			dm.State = model.StateBlock
			s.OpLog(c, dm.Oid, dm.Mid, time.Now().Unix(), 1, []int64{dm.ID}, "status", "", strconv.FormatInt(int64(dm.State), 10), "命中类型屏蔽（"+fmt.Sprint(mode)+"）", oplog.SourcePlayer, oplog.OperatorMember)
			return
		}
	}
	// 关键字过滤
	for _, text := range texts {
		if strings.Contains(strings.ToLower(msg), strings.ToLower(text)) {
			dm.State = model.StateBlock
			s.OpLog(c, dm.Oid, dm.Mid, time.Now().Unix(), 1, []int64{dm.ID}, "status", "", strconv.FormatInt(int64(dm.State), 10), "命中关键字屏蔽（"+text+"）", oplog.SourcePlayer, oplog.OperatorMember)
			return
		}
	}
	// 正则过滤
	for _, reg := range regexs {
		rc, rErr := regexp.Compile(reg)
		if rErr != nil {
			log.Error("regexp.Compile(%s) error(%v)", reg, rErr)
			continue
		}
		if rc.MatchString(msg) {
			dm.State = model.StateBlock
			s.OpLog(c, dm.Oid, dm.Mid, time.Now().Unix(), 1, []int64{dm.ID}, "status", "", strconv.FormatInt(int64(dm.State), 10), "命中正则屏蔽（"+reg+"）", oplog.SourcePlayer, oplog.OperatorMember)
			return
		}
	}
	// 验证up设置的屏蔽用户
	hashID := model.Hash(dm.Mid, uint32(dm.Content.IP))
	for _, user := range users {
		if hashID == user {
			dm.State = model.StateBlock
			s.OpLog(c, dm.Oid, dm.Mid, time.Now().Unix(), 1, []int64{dm.ID}, "status", "", strconv.FormatInt(int64(dm.State), 10), "屏蔽黑名单屏蔽（"+hashID+"）", oplog.SourcePlayer, oplog.OperatorMember)
			return
		}
	}
	return
}

func (s *Service) checkRateLimit(c context.Context, rank int32, mid int64) (err error) {
	now := time.Now().Unix()
	ltime, ok := model.LimitPerMin[rank]
	if !ok {
		ltime = model.LimitPerMin[0]
	}
	limiter, err := s.dao.DMLimitCache(c, mid)
	if err != nil {
		return
	}
	if limiter == nil {
		limiter = &model.Limiter{Allowance: ltime, Timestamp: now}
	}
	allowance := limiter.Allowance + ((now - limiter.Timestamp) * ltime / 600)
	if allowance > ltime {
		allowance = ltime
	}
	if allowance < 1 {
		err = ecode.DMMsgPubTooFast
		allowance = 0
	} else {
		allowance--
	}
	limiter = &model.Limiter{Allowance: allowance, Timestamp: now}
	s.dao.AddDMLimitCache(c, mid, limiter) // NOTE omit error
	return
}

func (s *Service) checkAccountInfo(c context.Context, mid int64) (profile *account.Profile, err error) {
	var (
		profileReply *account.ProfileReply
	)
	if profileReply, err = s.accountRPC.Profile3(c, &account.MidReq{
		Mid: mid,
	}); err != nil {
		log.Error("accRPC.UserInfo(%v) error(%v)", mid, err)
		return
	}
	if profileReply.GetProfile().GetIdentification() == 0 && profileReply.GetProfile().GetTelStatus() == 0 {
		err = ecode.UserCheckNoPhone
		return
	}
	if profileReply.GetProfile().GetIdentification() == 0 && profileReply.GetProfile().GetTelStatus() == 2 {
		err = ecode.UserCheckInvalidPhone
		return
	}
	if profileReply.GetProfile().GetEmailStatus() == 0 && profileReply.GetProfile().GetTelStatus() == 0 {
		err = ecode.UserCheckNoPhone
		return
	}
	if profileReply.GetProfile().GetSilence() == 1 {
		err = ecode.UserDisabled
		return
	}
	if profileReply.GetProfile().GetMoral() < 60 {
		err = ecode.LackOfScores
	}
	if profile = profileReply.GetProfile(); profile == nil {
		err = ecode.UserNotExist
	}
	return
}

func (s *Service) checkMsg(c context.Context, dm *model.DM, profile *account.Profile) (err error) {
	var (
		msg          = dm.Content.Msg
		msgLen       = len([]rune(dm.Content.Msg))
		isNormalMode = s.isNormalMode(dm.Content.Mode)
	)
	if msgRegex.MatchString(msg) { // 空白弹幕
		err = ecode.DMMsgIlleagel
		return
	}
	if profile.GetRank() < 20000 && profile.GetLevel() == 1 && msgLen > 20 {
		err = ecode.DMMsgTooLongLevel1
		return
	}
	if (msgLen > model.MaxLenDefMsg && isNormalMode) || (msgLen > model.MaxLen7Msg && dm.Content.Mode == 7) {
		err = ecode.DMMsgTooLong
		return
	}
	if isNormalMode && (strings.Contains(msg, `\n`) || strings.Contains(msg, `/n`)) {
		err = ecode.DMMsgIlleagel
		return
	}
	// 校验单字符刷屏
	if msgLen == 1 {
		var count int64
		if count, err = s.dao.CharPubCnt(c, dm.Mid, dm.Oid); err != nil {
			return
		}
		if count+1 > 3 {
			err = ecode.DMMsgPubTooFast
			return
		}
		if err = s.dao.IncrCharPubCnt(c, dm.Mid, dm.Oid); err != nil {
			return
		}
	} else {
		if err = s.dao.DelCharPubCnt(c, dm.Mid, dm.Oid); err != nil {
			return
		}
	}
	return
}

func (s *Service) checkPubRate(c context.Context, dm *model.DM, upid, rnd int64, rank int32) (err error) {
	ip := metadata.String(c, metadata.RemoteIP)
	cached, err := s.dao.MsgPublock(c, dm.Mid, dm.Content.Color, rnd, dm.Content.Mode, dm.Content.FontSize, ip, dm.Content.Msg)
	if err != nil {
		return
	}
	if cached {
		err = ecode.DMMsgPubTooFast
		return
	}
	s.dao.AddMsgPubLock(c, dm.Mid, dm.Content.Color, rnd, dm.Content.Mode, dm.Content.FontSize, ip, dm.Content.Msg)
	if !s.isSuperUser(rank) {
		if cached, err = s.dao.OidPubLock(c, dm.Mid, dm.Oid, ip); err != nil {
			return
		}
		if cached {
			err = ecode.DMMsgPubTooFast
			return
		}
		s.dao.AddOidPubLock(c, dm.Mid, dm.Oid, ip)
	}
	if rank <= 15000 {
		var count int64
		count, err = s.dao.PubCnt(c, dm.Mid, dm.Content.Color, dm.Content.Mode, dm.Content.FontSize, ip, dm.Content.Msg)
		if err != nil {
			return
		}
		if count >= 8 && dm.Mid != upid {
			arg := &account.MoralReq{
				Mid:    dm.Mid,
				Moral:  -0.25,
				Oper:   "",
				Reason: "恶意刷弹幕",
				Remark: "云屏蔽",
				RealIp: ip,
			}
			if _, err = s.accountRPC.AddMoral3(c, arg); err != nil {
				log.Error("s.accRPC.AddMoral2(%v) error(%v)", arg, err)
				return
			}
			err = ecode.DMMsgPubTooFast
			return
		}
		if err = s.dao.IncrPubCnt(c, dm.Mid, dm.Content.Color, dm.Content.Mode, dm.Content.FontSize, ip, dm.Content.Msg); err != nil {
			return
		}
	}
	return
}

func (s *Service) checkArchiveInfo(c context.Context, aid, oid int64, rank, mode int32) (arc *api.Arc, err error) {
	// if _, err = s.arcRPC.Video3(c, &arcMdl.ArgVideo2{
	// 	Aid:    aid,
	// 	Cid:    oid,
	// 	RealIP: metadata.String(c, metadata.RemoteIP),
	// }); err != nil {
	// 	log.Error("s.arcRPC.Video3(aid:%v,oid:%v) error(%v)", aid, oid, err)
	// 	return
	// }
	arg := &arcMdl.ArgAid2{
		Aid:    aid,
		RealIP: metadata.String(c, metadata.RemoteIP),
	}
	if arc, err = s.arcRPC.Archive3(c, arg); err != nil {
		log.Error("s.arcRPC.Archive3(%v) error(%v)", arg, err)
		return
	}
	if arc.State < 0 && arc.State != -6 {
		err = ecode.DMArchiveIlleagel // 禁止向未审核的视频发送弹幕
		return
	}
	return
}

func (s *Service) archiveUgcPay(c context.Context, mid int64, aid int64) (err error) {
	var (
		resp *ugcPayMdl.AssetRelationResp
	)
	resp, err = s.ugcPayRPC.AssetRelation(c, &ugcPayMdl.AssetRelationReq{
		Mid:   mid,
		Oid:   aid,
		Otype: model.UgcPayTypeArchive,
	})
	if err != nil {
		log.Error("archiveUgcPay(aid:%d,mid:%d),error(%v)", aid, mid, err)
		return
	}
	if resp.State != model.UgcPayRelationStatePaid {
		err = ecode.DMNotpayForPost
		return
	}
	return
}

func (s *Service) advanceComment(c context.Context, oid, mid int64, mode string) (adv *model.AdvanceCmt, err error) {
	if adv, err = s.dao.AdvanceCmtCache(c, oid, mid, mode); err != nil {
		log.Error("s.dao.AdvanceCmtCache mid=%d oid=%d mode=%s  error(%v)", mid, oid, mode, err)
		return
	}
	if adv == nil {
		if adv, err = s.dao.AdvanceCmt(c, oid, mid, mode); err != nil {
			log.Error("s.dao.AdvanceCmt mid=%d oid=%d mode=%s  error(%v)", mid, oid, mode, err)
			return
		}
		if adv == nil {
			adv = &model.AdvanceCmt{}
		}
		if err = s.dao.AddAdvanceCmtCache(c, oid, mid, mode, adv); err != nil {
			log.Error("s.dao.AddAdvanceCmtCache mid=%d  oid=%d mode=%s  error(%v)", mid, oid, mode, err)
			return
		}
	}
	return
}

func (s *Service) genDMID(c context.Context, dm *model.DM) (err error) {
	dmid, err := s.seqRPC.ID(c, s.seqDmArg)
	if err != nil {
		return
	}
	dm.ID = dmid
	dm.Content.ID = dmid
	if dm.ContentSpe != nil {
		dm.ContentSpe.ID = dmid
	}
	return
}

// checkMonitor check the oid is monitored
func (s *Service) checkMonitor(c context.Context, sub *model.Subject, dm *model.DM) (err error) {
	if dm.State != model.StateNormal {
		return
	}
	if sub.AttrVal(model.AttrSubMonitorBefore) == model.AttrYes {
		dm.State = model.StateMonitorBefore
	} else if sub.AttrVal(model.AttrSubMonitorAfter) == model.AttrYes {
		dm.State = model.StateMonitorAfter
	} else {
		return
	}
	return
}

func (s *Service) asyncAddDM(dm *model.DM, aid int64, tid int32) (err error) {
	var (
		data []byte
		msg  = &struct {
			*model.DM
			Aid int64 `json:"aid"`
			Tid int32 `json:"tid"`
		}{
			DM:  dm,
			Aid: aid,
			Tid: tid,
		}
		c = context.TODO()
	)
	if data, err = json.Marshal(msg); err != nil {
		log.Error("json.Marshal(%+v) error(%v)", msg, err)
		return
	}
	act := &model.Action{Action: model.ActAddDM, Data: data}
	for i := 0; i < 3; i++ {
		if err = s.dao.SendAction(c, fmt.Sprint(dm.Oid), act); err != nil {
			continue
		} else {
			break
		}
	}
	return
}

// 用户是否是特权用户
func (s *Service) isSuperUser(rank int32) bool {
	return rank >= 20000
}

// 判断弹幕模式是否是普通弹幕模式
func (s *Service) isNormalMode(mode int32) bool {
	if mode == 1 || mode == 4 || mode == 5 || mode == 6 {
		return true
	}
	return false
}

func (s *Service) checkOverseasUser(c context.Context) (err error) {
	if s.conf.Supervision.Completed {
		err = ecode.ServiceUpdate
		return
	}
	now := time.Now()
	loc, _ := time.LoadLocation("Asia/Shanghai")
	startTime, _ := time.ParseInLocation("2006-01-02 15:04:05", s.conf.Supervision.StartTime, loc)
	endTime, _ := time.ParseInLocation("2006-01-02 15:04:05", s.conf.Supervision.EndTime, loc)
	if now.Before(startTime) || now.After(endTime) {
		err = nil
		return
	}
	arg := &locmdl.ArgIP{IP: metadata.String(c, metadata.RemoteIP)}
	zone, err := s.locationRPC.Info(c, arg)
	if err != nil {
		log.Error("s.locationRPC.Info(%s) error(%v)", metadata.String(c, metadata.RemoteIP), err)
		err = nil
		return
	}
	if !strings.EqualFold(zone.Country, s.conf.Supervision.Location) {
		err = ecode.ServiceUpdate
	}
	return
}

func (s *Service) checkShield(c context.Context, aid int64, dm *model.DM) {
	if _, ok := s.aidSheild[aid]; !ok {
		return
	}
	if _, ok := s.midsSheild[dm.Mid]; !ok {
		return
	}
	// hit
	dm.State = model.StateBlock
	s.OpLog(c, dm.Oid, dm.Mid, time.Now().Unix(), 1, []int64{dm.ID}, "status", "", strconv.FormatInt(int64(dm.State), 10), "弹幕指定稿件黑名单屏蔽", oplog.SourcePlayer, oplog.OperatorMember)
}