openbilibili/app/admin/main/member/service/block/block.go

package block

import (
	"context"
	"sync"
	"time"

	model "go-common/app/admin/main/member/model/block"
	xsql "go-common/library/database/sql"
	"go-common/library/log"
	"go-common/library/sync/errgroup"

	"github.com/pkg/errors"
)

// Search .
func (s *Service) Search(c context.Context, mids []int64) (infos []*model.BlockInfo, err error) {
	var (
		users       []*model.DBUser
		userDetails []*model.DBUserDetail
		eg          errgroup.Group
		mapMu       sync.Mutex
		userMap     = make(map[int64]*model.BlockInfo)
	)
	if users, err = s.dao.Users(c, mids); err != nil {
		return
	}
	if userDetails, err = s.dao.UserDetails(c, mids); err != nil {
		return
	}
	infos = make([]*model.BlockInfo, 0, len(mids))
	for _, m := range mids {
		mid := m
		eg.Go(func() (err error) {
			info := &model.BlockInfo{
				MID: mid,
			}
			// 1. account 数据
			if info.Nickname, info.TelStatus, info.Level, info.RegTime, err = s.AccountInfo(context.Background(), mid); err != nil {
				log.Error("%+v", err)
				err = nil
			}
			if info.Nickname == "" {
				log.Info("user mid(%d) not found", info.MID)
				return
			}
			// 2. 封禁状态
			for i := range users {
				if users[i].MID == mid {
					info.ParseStatus(users[i])
					break
				}
			}
			// 3. 封禁次数
			for i := range userDetails {
				if userDetails[i].MID == mid {
					info.BlockCount = userDetails[i].BlockCount
					break
				}
			}
			// 4. spy 分值
			if info.SpyScore, err = s.SpyScore(context.Background(), mid); err != nil {
				log.Error("%+v", err)
				err = nil
				info.SpyScore = -1
			}
			// 5. figure 排名
			if info.FigureRank, err = s.FigureRank(context.Background(), mid); err != nil {
				log.Error("%+v", err)
				err = nil
				info.FigureRank = -1
			}
			// 6. extra 额外账号信息
			if info.Tel, err = s.telInfo(context.Background(), mid); err != nil {
				log.Error("%+v", err)
				err = nil
				info.Tel = "N/A"
			}
			if info.Mail, err = s.mailInfo(context.Background(), mid); err != nil {
				log.Error("%+v", err)
				err = nil
				info.Mail = "N/A"
			}
			if info.Username, err = s.userID(context.Background(), mid); err != nil {
				log.Error("%+v", err)
				err = nil
				info.Username = "N/A"
			}

			mapMu.Lock()
			userMap[info.MID] = info
			mapMu.Unlock()
			return
		})
	}
	eg.Wait()
	for _, mid := range mids {
		if info, ok := userMap[mid]; ok {
			infos = append(infos, info)
		}
	}
	return
}

// History .
func (s *Service) History(c context.Context, mid int64, ps, pn int, desc bool) (history *model.BlockDetail, err error) {
	var (
		start     = (pn - 1) * ps
		limit     = ps
		dbHistory []*model.DBHistory
		dbUser    *model.DBUser
	)
	history = &model.BlockDetail{}
	if dbUser, err = s.dao.User(c, mid); err != nil {
		return
	}
	if dbUser != nil {
		history.Status = dbUser.Status
	}
	if history.Total, err = s.dao.HistoryCount(c, mid); err != nil {
		return
	}
	if dbHistory, err = s.dao.History(c, mid, start, limit, desc); err != nil {
		return
	}
	history.History = make([]*model.BlockHistory, 0, len(dbHistory))
	for i := range dbHistory {
		his := &model.BlockHistory{}
		his.ParseDB(dbHistory[i])
		history.History = append(history.History, his)
	}
	return
}

// BatchBlock .
func (s *Service) BatchBlock(c context.Context, p *model.ParamBatchBlock) (err error) {
	var (
		tx       *xsql.Tx
		duration = time.Duration(p.Duration) * time.Hour * 24
		source   model.BlockSource
		stime    = time.Now()
	)
	if tx, err = s.dao.BeginTX(c); err != nil {
		return
	}
	if p.Source == model.BlockMgrSourceSys {
		// 系统封禁
		source = model.BlockSourceSys
	} else if p.Source == model.BlockMgrSourceCredit {
		// 小黑屋封禁
		source = model.BlockSourceBlackHouse
		if err = s.dao.BlackhouseBlock(context.Background(), p); err != nil {
			return
		}
	}
	for _, mid := range p.MIDs {
		if err = s.action(c, tx, mid, p.AdminID, p.AdminName, source, p.Area, p.Reason, p.Comment, p.Action, duration, p.Notify, stime); err != nil {
			tx.Rollback()
			return
		}
	}
	if err = tx.Commit(); err != nil {
		return
	}
	// 发送站内信
	if p.Notify {
		s.mission(func() {
			if notifyErr := s.notifyMSG(context.Background(), p.MIDs, source, p.Action, p.Area, p.Reason, p.Duration); notifyErr != nil {
				log.Error("%+v", notifyErr)
				return
			}
		})
	}
	s.mission(func() {
		s.AddAuditLog(context.Background(), p.Action, p.AdminID, p.AdminName, p.MIDs, duration, source, p.Area, p.Reason, p.Comment, p.Notify, stime)
	})
	s.asyncPurgeCache(p.MIDs)
	return
}

// BatchRemove .
func (s *Service) BatchRemove(c context.Context, p *model.ParamBatchRemove) (err error) {
	var (
		tx    *xsql.Tx
		stime = time.Now()
	)
	if tx, err = s.dao.BeginTX(c); err != nil {
		return
	}

	for _, mid := range p.MIDs {
		if err = s.action(c, tx, mid, p.AdminID, p.AdminName, model.BlockSourceManager, model.BlockAreaNone, "", p.Comment, model.BlockActionAdminRemove, 0, p.Notify, stime); err != nil {
			tx.Rollback()
			return
		}
	}
	if err = tx.Commit(); err != nil {
		return
	}
	// 发送站内信
	if p.Notify {
		s.mission(func() {
			if notifyErr := s.notifyMSG(context.Background(), p.MIDs, model.BlockSourceManager, model.BlockActionAdminRemove, model.BlockAreaNone, "", 0); notifyErr != nil {
				log.Error("%+v", notifyErr)
				return
			}
		})
	}
	s.mission(func() {
		s.AddAuditLog(context.Background(), model.BlockActionAdminRemove, p.AdminID, p.AdminName, p.MIDs, 0, model.BlockSourceManager, model.BlockAreaNone, "", p.Comment, p.Notify, stime)
	})
	s.asyncPurgeCache(p.MIDs)
	return
}

// notifyMSG .
func (s *Service) notifyMSG(c context.Context, mids []int64, source model.BlockSource, action model.BlockAction, area model.BlockArea, reason string, days int64) (err error) {
	code, title, content := s.MSGInfo(source, action, area, reason, days)
	log.Info("block admin title : %s , content : %s , mids : %+v", title, content, mids)
	if err = s.dao.SendSysMsg(context.Background(), code, mids, title, content, ""); err != nil {
		return
	}
	return
}

func (s *Service) action(c context.Context, tx *xsql.Tx, mid int64, adminID int64, adminName string, source model.BlockSource, area model.BlockArea, reason, comment string, action model.BlockAction, duration time.Duration, notify bool, stime time.Time) (err error) {
	var (
		db = &model.DBHistory{
			MID:       mid,
			AdminID:   adminID,
			AdminName: adminName,
			Source:    source,
			Area:      area,
			Reason:    reason,
			Comment:   comment,
			Action:    action,
			StartTime: stime,
			Duration:  int64(duration / time.Second),
			Notify:    notify,
		}
		blockStatus model.BlockStatus
	)
	if err = s.dao.TxInsertHistory(c, tx, db); err != nil {
		return
	}
	switch action {
	case model.BlockActionAdminRemove, model.BlockActionSelfRemove:
		blockStatus = model.BlockStatusFalse
	case model.BlockActionLimit:
		switch source {
		case model.BlockSourceBlackHouse:
			blockStatus = model.BlockStatusCredit
		default:
			blockStatus = model.BlockStatusLimit
		}
		s.mission(func() {
			if err = s.dao.UpdateAddBlockCount(context.Background(), mid); err != nil {
				log.Error("%+v", err)
			}
		})
	case model.BlockActionForever:
		blockStatus = model.BlockStatusForever
		s.mission(func() {
			if err = s.dao.UpdateAddBlockCount(context.Background(), mid); err != nil {
				log.Error("%+v", err)
			}
		})
	default:
		err = errors.Errorf("unknown block action [%d]", action)
		return
	}
	if err = s.dao.TxUpdateUser(c, tx, mid, blockStatus); err != nil {
		return
	}
	return
}

func (s *Service) userID(c context.Context, mid int64) (id string, err error) {
	return "N/A", nil
}

func (s *Service) mailInfo(c context.Context, mid int64) (mail string, err error) {
	if mail, err = s.dao.MailInfo(c, mid); mail == "" {
		mail = "N/A"
	}
	return
}

// TelInfo .
func (s *Service) telInfo(c context.Context, mid int64) (tel string, err error) {
	if tel, err = s.dao.TelInfo(c, mid); err != nil {
		return
	}
	if len(tel) == 0 {
		tel = "N/A"
		return
	}
	if len(tel) < 4 {
		tel = tel[:1] + "****"
		return
	}
	tel = tel[:3] + "****" + tel[len(tel)-4:]
	return
}

func (s *Service) asyncPurgeCache(mids []int64) {
	_ = s.cache.Do(context.Background(), func(ctx context.Context) {
		for _, mid := range mids {
			if cacheErr := s.dao.DeleteUserCache(ctx, mid); cacheErr != nil {
				log.Error("%+v", cacheErr)
			}
			if cacheErr := s.dao.DeleteUserDetailCache(ctx, mid); cacheErr != nil {
				log.Error("%+v", cacheErr)
			}
			if databusErr := s.accountNotify(ctx, mid); databusErr != nil {
				log.Error("%+v", databusErr)
			}
		}
	})
}