fonchain-fiee/pkg/service/artistInfo/asUser/artistInfoScript.go

// Package asUser -----------------------------
// @file      : artistInfoScript.go
// @author    : JJXu
// @contact   : wavingbear@163.com
// @time      : 2024/1/16 11:08
// -------------------------------------------
package asUser

import (
	"context"
	"dubbo.apache.org/dubbo-go/v3/common/logger"
	"errors"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-main/api/artist"
	"github.com/fonchain_enterprise/fonchain-main/api/artistInfoUser"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"
	"github.com/gin-gonic/gin"
	"sync"
	"time"
)

func SyncLowArtistHandler(c *gin.Context) {
	//全量更新DynamicUserData中的数据
	err := DynamicUserService.SyncAllOfDynamicUserData()
	if err != nil {
		service.Error(c, e.Failed, err, "同步失败")
		return
	}
	service.Success(c, map[string]any{
		"isUpdateCompleted": DynamicUserService.CompleteState.IsUpdateCompleted(),
		"latestUpdateTime":  DynamicUserService.CompleteState.LatestUpdateTime(),
		"err":               fmt.Sprintf("%v", err),
	})
}

// dynamicUser视图更新状态
type dynamicUserUpdateState struct {
	updateCompleted  bool
	latestUpdateTime *time.Time
	rwLock           sync.RWMutex
}

func (d *dynamicUserUpdateState) SetCompleteState(completed bool) {
	d.rwLock.Lock()
	d.updateCompleted = completed
	d.rwLock.Unlock()
}
func (d *dynamicUserUpdateState) IsUpdateCompleted() bool {
	d.rwLock.RLock()
	defer d.rwLock.RUnlock()
	return d.updateCompleted
}
func (d *dynamicUserUpdateState) LatestUpdateTime() *time.Time {
	d.rwLock.RLock()
	defer d.rwLock.RUnlock()
	return d.latestUpdateTime
}

var DynamicUserService *dynamicUserService

func NewDynamicUserService() {
	DynamicUserService = &dynamicUserService{artistUidChan: make(chan string, 100), userIdChan: make(chan int64, 100)}
	go DynamicUserService.Run()
}

type dynamicUserService struct {
	artistUidChan           chan string
	userIdChan              chan int64
	syncDynamicUserDataLock sync.Mutex
	CompleteState           dynamicUserUpdateState //物理视图更新状态
}

func (d *dynamicUserService) Run() {
	for {
		select {
		case uid := <-d.artistUidChan:
			if uid == "" {
				break
			}
			_, err := service.GrpcArtistInfoUserImpl.SyncDynamicUser(context.Background(), &artistInfoUser.SyncDynamicUserRequest{ArtistUid: uid})
			if err != nil {
				logger.Errorf("同步画家[artistUid:%s]物理视图失败,系统将切换至user_view视图。err:%v", uid, err.Error())
				d.CompleteState.SetCompleteState(false)
			}
		case userId := <-d.userIdChan:
			_, err := service.GrpcArtistInfoUserImpl.SyncDynamicUser(context.Background(), &artistInfoUser.SyncDynamicUserRequest{UserId: userId})
			if err != nil {
				logger.Errorf("同步画家[userId:%s]物理视图失败,系统将切换至user_view视图。err:%v", userId, err.Error())
				d.CompleteState.SetCompleteState(false)
			}
		default:
			time.Sleep(200 * time.Millisecond)
		}
	}
}
func (d *dynamicUserService) UpdateUserWistArtistUid(artistUidList ...string) {
	for _, artistUid := range artistUidList {
		d.artistUidChan <- artistUid
	}
}
func (d *dynamicUserService) UpdateUserWithUserId(userIds ...int64) {
	for _, userId := range userIds {
		d.userIdChan <- userId
	}
}
func (d *dynamicUserService) SyncAllOfDynamicUserData() error {
	if d.syncDynamicUserDataLock.TryLock() {
		return errors.New("任务正在执行中，请稍后再试")
	}
	d.CompleteState.SetCompleteState(false)
	defer d.syncDynamicUserDataLock.Unlock()
	var ctx = context.Background()
	lowList, err := service.GrpcArtistImpl.LowArtistList(ctx, &artist.LowArtistListReq{
		Page:     1,
		PageSize: -1,
	})
	defer func() {
		if err != nil {
			d.CompleteState.SetCompleteState(false)
		} else {
			d.CompleteState.SetCompleteState(true)
		}
	}()
	if err != nil {
		return errors.New("获取低优先级画家失败,err:" + err.Error())
	}
	var nameList []string
	for _, v := range lowList.Data {
		nameList = append(nameList, v.RealName)
	}
	_, err = service.GrpcArtistInfoUserImpl.UpdateLowArtistList(ctx, &artistInfoUser.UpdateLowArtistListRequest{ArtistNameList: nameList})
	if err != nil {
		return errors.New("更新低优先级画家失败,err：" + err.Error())
	}
	return nil
}

func (d *dynamicUserService) UpdateDynamicUserData(artistUserList ...string) error {
	if d.syncDynamicUserDataLock.TryLock() {
		d.CompleteState.SetCompleteState(false)
	}
	d.syncDynamicUserDataLock.Unlock()
	_, err := service.GrpcArtistInfoUserImpl.SyncDynamicUser(context.Background(), &artistInfoUser.SyncDynamicUserRequest{ArtistUidList: artistUserList})
	return err
}