log-server/service/log/loging/logical_log.go

package loging

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/go-redis/redis/v8"
	"go.uber.org/zap"
	"gorm.io/gorm"
	"log-server/global"
	"log-server/model/log"
	"log-server/model/log/request"
	"log-server/model/typeManage"
	"log-server/service/cache"
	"log-server/utils"
	"strconv"
	"strings"
	"time"
)

var (
	FailStatus                  = "fail"
	OkStatus                    = "ok"
	NoLogStatus                 = "notStatus"
	GameCacheKey                = "%s:game"
	NodeGameCacheKey            = "%s:log"
	reportPointsKey             = "%s:logUuid:"
	logUuidAccountGameId        = "%s:logUuid:account:gameId"
	ComputerCacheKey            = "%s:computer:list"
	ComputerPullAccountCacheKey = "%s:computer:%s:pullAccount:"
	ComputerEnterMainCacheKey   = "%s:computer:%s:enterMain:"
	ComputerTaskSuccessCacheKey = "%s:computer:%s:taskSuccess:"
	GameFeeRateCacheKey         = "%s:game:gameFeeRate:%d"
	GameComputerRateCacheKey    = "%s:Computer:Rate:%s:"
	GamePcFeeRateCacheKey       = "%s:gamePc:gameFeeRate:%d:%s"
	OnLineComputerNum           = "%s:OnLineComputerNum:"
	PcReportingLog              = "%s:pc:Reporting:%s"
	GameDeviceErrKey            = "%s:device:%d"
	GameDeviceAccountErrKey     = "%s:deviceAccount:%d"
	GameDeviceUuidKey           = "%s:GameDeviceUuid:%s"
)

type LogicalLog struct {
	Status     int // 状态
	Request    request.AddLogRequest
	cache      cache.Cache
	ScriptType int
	Person     typeManage.ResponsiblePerson
}

func (s *LogicalLog) CurrentDate() (current string) {
	current = time.Now().Format("2006-01-02")
	return
}

func (s *LogicalLog) YesterdayDate() (yesterday string) {
	yesterday = time.Now().Add(-time.Hour * 24).Format("2006-01-02")
	return
}

func (s *LogicalLog) DataAdd() (err error) {
	logInfo, err := s.RepositoryData()
	if err != nil {
		return err
	}
	err = s.LogAdd(logInfo)
	if err != nil {
		return
	}
	/*if s.Status == 0 {
		_ = s.errLogAdd(logInfo)
	}*/
	ctx := context.Background()
	err = s.SetGameCache(ctx, s.CurrentDate(), logInfo.GameId)
	if err != nil {
		return
	}
	err = s.SetAccountGameIdCache(ctx, s.CurrentDate(), logInfo)
	if err != nil {
		return
	}
	if logInfo.PcCode != "" {
		err = s.SetComputerCache(ctx, s.CurrentDate(), logInfo.PcCode, logInfo.Operator)
		_ = s.StatisticsComputerRateData(ctx, logInfo.PcCode, logInfo.GameId)
		_ = s.SetOnlineComputerNumCache(ctx, s.CurrentDate(), logInfo.PcCode, logInfo.Operator)
		s.SetPcReportingLog(ctx, logInfo.PcCode, logInfo.Operator)
	}
	return
}

func (s *LogicalLog) NoLogStatusDataAdd(ctx context.Context) (err error) {
	logInfo, err := s.RepositoryData()
	if err != nil {
		return err
	}
	err = s.LogAdd(logInfo)
	return
}

func (s *LogicalLog) getLogByUuid(uuid string) (log log.Loging, err error) {
	createDate := time.Now().Format("2006-01")
	db := global.GVA_DB.Table("loging_" + createDate)
	db = db.Where("log_uuid = ?", uuid)
	db = db.Where("coding = 4101099 or coding = 4103099")
	db.First(&log)
	return
}

func (s *LogicalLog) GetLogByUuidCoding(uuid string, coding int, scriptType int) (log log.Loging, err error) {
	createDate := time.Now().Format("2006-01")
	db := global.GVA_DB.Table("loging_" + createDate)
	db = db.Where("log_uuid = ?", uuid)
	db = db.Where("coding = ?", coding)
	db = db.Where("script_type = ?", scriptType)
	db.First(&log)
	return
}

func (s *LogicalLog) RepositoryData() (*log.Loging, error) {
	nodeCode, typeCode, err := s.codeData()
	if err != nil {
		return nil, err
	}
	if s.Request.GameId == 0 {
		loging, err := s.GetAccountGameIdCache(context.Background(), s.CurrentDate(), s.Request.LogUuid)
		if err != nil {
			return nil, err
		}
		if loging.GameId == 0 {
			return nil, errors.New("没有找到数据" + s.Request.LogUuid)
		}
		s.Request.GameId = loging.GameId
		s.Request.Account = loging.Account
		s.Request.DeviceId = loging.DeviceId
		s.Request.ComputerType = loging.ComputerType
		s.Request.EnvCode = loging.EnvCode
		s.Request.Operator = loging.Operator
		s.Request.PcCode = loging.PcCode
		s.Request.PcIp = loging.PcIp
		s.Request.PcMac = loging.PcMac
		s.Request.SimulatorIp = loging.SimulatorIp
		s.Request.SimulatorMac = loging.SimulatorMac
		s.Request.AccountType = loging.AccountType
		s.Request.TaskType = loging.TaskType
	}
	logInfo := new(log.Loging)
	logInfo.Coding = s.Request.Coding
	logInfo.GameId = s.Request.GameId
	logInfo.Status = s.Status
	logInfo.Account = s.Request.Account
	logInfo.NodeCoding = nodeCode
	logInfo.TypeCoding = typeCode
	logInfo.DeviceId = s.Request.DeviceId
	logInfo.ComputerType = s.Request.ComputerType
	logInfo.EnvCode = s.Request.EnvCode
	logInfo.LogUuid = s.Request.LogUuid
	logInfo.Operator = s.Request.Operator
	logInfo.PcCode = s.Request.PcCode
	logInfo.PcIp = s.Request.PcIp
	logInfo.SimulatorIp = s.Request.SimulatorIp
	logInfo.SimulatorMac = s.Request.SimulatorMac
	logInfo.PcMac = s.Request.PcMac
	logInfo.AccountType = s.Request.AccountType
	logInfo.TaskType = s.Request.TaskType
	logInfo.ScriptType = s.ScriptType
	logInfo.Remarks = s.Request.Remarks
	logInfo.CreateDate = time.Now().Format("2006-01-02")
	logInfo.CreateTime = time.Now().Format("2006-01-02 15:04:05")
	return logInfo, err
}

func (s *LogicalLog) codeData() (nodeCode, typeCode int, err error) {
	code := strconv.Itoa(s.Request.Coding)
	nodeCodeStr := code[:3]
	typeCodeStr := code[:5]
	nodeCode, err = strconv.Atoi(nodeCodeStr)
	if err != nil {
		return
	}
	typeCode, err = strconv.Atoi(typeCodeStr)
	return
}

func (s *LogicalLog) LogAdd(l *log.Loging) error {
	createDate := l.CreateDate
	splitTime := strings.Split(createDate, "-")
	date := splitTime[0] + "-" + splitTime[1]
	if date != "2022-11" {
		table := "loging_" + splitTime[0] + "-" + splitTime[1]
		return global.GVA_DB.Table(table).Create(&l).Error
	}
	return global.GVA_DB.Create(&l).Error
}

func (s *LogicalLog) errLogAdd(l *log.Loging) error {
	return global.GVA_DB.Table("err_log").Create(&l).Error
}

func (s *LogicalLog) ReportPointsLog(ctx context.Context, request1 request.AddLogRequest) (err error) {
	key := reportPointsKey + request1.LogUuid
	status, err := global.GVA_REDIS.Exists(ctx, key).Result()
	if err != nil {
		return
	}
	var reportPointsData []*request.ReportPointsData
	if status == 0 {
		reportData := new(request.ReportPointsData)
		reportData.Data = request1.ReportPointsData
		reportData.Date = time.Now().Format("2006-01-02 15:04:05")
		reportPointsData = append(reportPointsData, reportData)
		str, _ := json.Marshal(reportPointsData)
		global.GVA_REDIS.Set(ctx, key, str, time.Minute*20)
	} else {
		str, _ := global.GVA_REDIS.Get(ctx, key).Result()
		err := json.Unmarshal([]byte(str), &reportPointsData)
		if err != nil {
			return err
		}
		reportData := new(request.ReportPointsData)
		reportData.Data = request1.ReportPointsData
		reportData.Date = time.Now().Format("2006-01-02 15:04:05")
		reportPointsData = append(reportPointsData, reportData)
		str1, _ := json.Marshal(reportPointsData)
		global.GVA_REDIS.Set(ctx, key, str1, time.Minute*20)
	}
	return err
}

func (s *LogicalLog) ReportPointsLogAdd(ctx context.Context, request1 request.AddLogRequest, status int) (err error) {
	key := reportPointsKey + request1.LogUuid
	isNull, err := global.GVA_REDIS.Exists(ctx, key).Result()
	if err != nil {
		return
	}
	if isNull == 0 {
		return
	} else {
		str, err := global.GVA_REDIS.Get(ctx, key).Result()
		if err != nil {
			return err
		}
		logIfo, _ := s.GetAccountGameIdCache(ctx, s.CurrentDate(), request1.LogUuid)
		var reportPointsData []*request.ReportPointsData
		err = json.Unmarshal([]byte(str), &reportPointsData)
		if err != nil {
			return err
		}
		reportPoints := new(log.ReportPointsLog)
		reportPoints.ReportPointsData = str
		reportPoints.LogUuid = request1.LogUuid
		reportPoints.Status = status
		reportPoints.Account = logIfo.Account
		reportPoints.GameId = logIfo.GameId
		reportPoints.Coding = logIfo.Coding
		reportPoints.ReportPointsNum = len(reportPointsData)
		reportPoints.CreateDate = time.Now().Format("2006-01-02")
		reportPoints.CreateTime = time.Now().Format("2006-01-02 15:04:05")
		err = global.GVA_DB.Create(&reportPoints).Error
		if err != nil {
			return err
		}
		global.GVA_REDIS.Del(ctx, key)
		err = s.DelAccountGameIdCache(ctx, s.CurrentDate(), logIfo.LogUuid)
	}
	return
}

func (s *LogicalLog) ExistsKey(ctx context.Context, key string) (bool, error) {
	isNull, err := global.GVA_REDIS.Exists(ctx, key).Result()
	if err != nil {
		return false, err
	}
	if isNull == 0 {
		return false, nil
	} else {
		return true, nil
	}
}

func (s *LogicalLog) ExistsHsKey(ctx context.Context, key string, field string) (bool, error) {
	isNull, err := global.GVA_REDIS.HExists(ctx, key, field).Result()
	if err != nil {
		return false, err
	}
	return isNull, err
}

// 前3个编号
func (s *LogicalLog) NodeLogSetNum(ctx context.Context, date string, gameId int, code string, status string, taskType int) (err error) {
	node := code[:3]
	err = s.LogSetNum(ctx, date, gameId, node, status, taskType)
	return
}

// 前5个编号
func (s *LogicalLog) TypeLogSetNum(ctx context.Context, date string, gameId int, code string, status string, taskType int) (err error) {
	node := code[:5]
	err = s.LogSetNum(ctx, date, gameId, node, status, taskType)
	return
}

// 整个编号
func (s *LogicalLog) CodeLogSetNum(ctx context.Context, date string, gameId int, code string, status string, taskType int) (err error) {
	err = s.LogSetNum(ctx, date, gameId, code, status, taskType)
	return
}

// 前5个编号和整个编号缓存
func (s *LogicalLog) PartTypeLogSetNum(ctx context.Context, date string, gameId int, code string, status string, taskType int) (err error) {
	node := code[:5]
	err = s.LogSetNum(ctx, date, gameId, node, status, taskType)
	if err != nil {
		return
	}
	err = s.LogSetNum(ctx, date, gameId, code, status, taskType)
	return
}

func (s *LogicalLog) LogSetNum(ctx context.Context, date string, gameId int, code string, status string, taskType int) (err error) {
	strGameId := strconv.Itoa(gameId)
	nodeGameCacheKey := fmt.Sprintf(NodeGameCacheKey, date)
	key := nodeGameCacheKey + ":" + strGameId + ":" + strconv.Itoa(taskType) + ":" + status + ":" + code
	err = s.SetCacheNum(ctx, key)
	return
}

func (s *LogicalLog) SetCacheNum(ctx context.Context, key string) (err error) {
	bl, err := s.ExistsKey(ctx, key)
	if err != nil {
		return err
	}
	if !bl {
		err = global.GVA_REDIS.Set(ctx, key, 1, time.Hour*48).Err()
		return err
	} else {
		err = global.GVA_REDIS.Incr(ctx, key).Err()
		return err
	}
}

func (s *LogicalLog) NodeLogGetNum(ctx context.Context, date string, gameId int, code string, status string, taskType int) (num int, err error) {
	node := code[:3]
	num, err = s.LogGetNum(ctx, date, gameId, node, status, taskType)
	return
}

func (s *LogicalLog) TypeLogGetNum(ctx context.Context, date string, gameId int, code string, status string, taskType int) (num int, err error) {
	node := code[:5]
	num, err = s.LogGetNum(ctx, date, gameId, node, status, taskType)
	return
}

func (s *LogicalLog) CodeLogGetNum(ctx context.Context, date string, gameId int, code string, status string, taskType int) (num int, err error) {
	num, err = s.LogGetNum(ctx, date, gameId, code, status, taskType)
	return
}

func (s *LogicalLog) LogGetNum(ctx context.Context, date string, gameId int, code string, status string, taskType int) (num int, err error) {
	strGameId := strconv.Itoa(gameId)
	nodeGameCacheKey := fmt.Sprintf(NodeGameCacheKey, date)
	key := nodeGameCacheKey + ":" + strGameId + ":" + strconv.Itoa(taskType) + ":" + status + ":" + code
	num, err = s.GetCacheNum(ctx, key)
	return
}

func (s *LogicalLog) GetCacheNum(ctx context.Context, key string) (num int, err error) {
	num, err = global.GVA_REDIS.Get(ctx, key).Int()
	if err != nil {
		if err == redis.Nil {
			return 0, nil
		}
		return 0, err
	}
	return num, err
}

func (s *LogicalLog) SetGameCache(ctx context.Context, date string, gameId int) (err error) {
	key := fmt.Sprintf(GameCacheKey, date)
	_, err = global.GVA_REDIS.HSet(ctx, key, gameId, 1).Result()
	if err != nil {
		return err
	}
	return err
}

func (s *LogicalLog) GetGameCache(ctx context.Context, date string) (mps map[string]string, err error) {
	key := fmt.Sprintf(GameCacheKey, date)
	mps, err = global.GVA_REDIS.HGetAll(ctx, key).Result()
	if err != nil {
		return mps, err
	}
	return mps, err
}

func (s *LogicalLog) SetAccountGameIdCache(ctx context.Context, date string, logInfo *log.Loging) (err error) {
	key := fmt.Sprintf(logUuidAccountGameId, date)
	value, _ := json.Marshal(logInfo)
	_, err = global.GVA_REDIS.HGet(ctx, key, logInfo.LogUuid).Result()
	if err != nil {
		if err == redis.Nil {
			_, err = global.GVA_REDIS.HSet(ctx, key, logInfo.LogUuid, value).Result()
			if err != nil {
				return err
			}
		} else {
			return err
		}
	}

	return err
}

func (s *LogicalLog) GetAccountGameIdCache(ctx context.Context, date string, uuid string) (logInfo log.Loging, err error) {
	key := fmt.Sprintf(logUuidAccountGameId, date)
	data, err := global.GVA_REDIS.HGet(ctx, key, uuid).Result()
	if err != nil {
		if err == redis.Nil {
			logInfo, err = s.getLogByUuid(uuid)
			return logInfo, nil
		}
		return logInfo, err
	}
	err = json.Unmarshal([]byte(data), &logInfo)
	return
}

func (s *LogicalLog) DelAccountGameIdCache(ctx context.Context, date string, uuid string) (err error) {
	key := fmt.Sprintf(logUuidAccountGameId, date)
	_, err = global.GVA_REDIS.HDel(ctx, key, uuid).Result()
	return
}

func (s *LogicalLog) GetGameStatisticsCacheKeys(ctx context.Context, date string, gameId int, taskType int) (keys []string, err error) {
	strGameId := strconv.Itoa(gameId)
	nodeGameCacheKey := fmt.Sprintf(NodeGameCacheKey, date)
	key := nodeGameCacheKey + ":" + strGameId + ":" + strconv.Itoa(taskType) + ":*"
	keys, err = global.GVA_REDIS.Keys(ctx, key).Result()
	return
}

func (s *LogicalLog) ByCacheKeyGetEndNode(key string) (code string) {
	str := strings.Split(key, ":")
	code = str[len(str)-1]
	return
}

func (s *LogicalLog) SetUuidCodeCache(ctx context.Context, date string, uuid string, code int, gameId int) (err error) {
	key := fmt.Sprintf(reportPointsKey, date) + strconv.Itoa(gameId) + ":" + uuid
	_, err = global.GVA_REDIS.HSet(ctx, key, code, 1).Result()
	if err != nil {
		return err
	}
	return err
}

func (s *LogicalLog) ExistsUuidCodeCache(ctx context.Context, date string, uuid string, code int, gameId int) (b bool, err error) {
	key := fmt.Sprintf(reportPointsKey, date) + strconv.Itoa(gameId) + ":" + uuid
	b, err = s.ExistsHsKey(ctx, key, strconv.Itoa(code))
	if err != nil {
		return false, err
	}
	return
}

func (s *LogicalLog) GetCacheKeys(ctx context.Context, keys string) (key []string, err error) {
	key, err = global.GVA_REDIS.Keys(ctx, keys).Result()
	return
}

func (s *LogicalLog) DelStatisticsNumCache(ctx context.Context, date string, gameId int) (err error) {
	key1FailStatus := fmt.Sprintf(NodeGameCacheKey, date) + ":" + strconv.Itoa(gameId) + ":" + "1" + ":" + FailStatus + ":*"
	key1NoLogStatus := fmt.Sprintf(NodeGameCacheKey, date) + ":" + strconv.Itoa(gameId) + ":" + "1" + ":" + NoLogStatus + ":*"
	key1OkStatus := fmt.Sprintf(NodeGameCacheKey, date) + ":" + strconv.Itoa(gameId) + ":" + "1" + ":" + OkStatus + ":*"
	key0FailStatus := fmt.Sprintf(NodeGameCacheKey, date) + ":" + strconv.Itoa(gameId) + ":" + "0" + ":" + FailStatus + ":*"
	key0NoLogStatus := fmt.Sprintf(NodeGameCacheKey, date) + ":" + strconv.Itoa(gameId) + ":" + "0" + ":" + NoLogStatus + ":*"
	key0OkStatus := fmt.Sprintf(NodeGameCacheKey, date) + ":" + strconv.Itoa(gameId) + ":" + "0" + ":" + OkStatus + ":*"
	fmt.Println(key1FailStatus)
	fmt.Println(key1NoLogStatus)
	fmt.Println(key1OkStatus)
	fmt.Println(key0FailStatus)
	fmt.Println(key0NoLogStatus)
	fmt.Println(key0OkStatus)
	err = s.cache.DelBatheCache(ctx, key1FailStatus)
	err = s.cache.DelBatheCache(ctx, key1NoLogStatus)
	err = s.cache.DelBatheCache(ctx, key1OkStatus)
	err = s.cache.DelBatheCache(ctx, key0FailStatus)
	err = s.cache.DelBatheCache(ctx, key0NoLogStatus)
	err = s.cache.DelBatheCache(ctx, key0OkStatus)
	if err != nil {
		return err
	}
	return
}

func (s *LogicalLog) DelUuidCodeCache(ctx context.Context, date string, gameId int) (err error) {
	key := fmt.Sprintf(reportPointsKey, date) + strconv.Itoa(gameId) + ":*"
	keys, err := global.GVA_REDIS.Keys(ctx, key).Result()
	for _, v := range keys {
		err = s.cache.DelBatheHsCache(ctx, v)
	}
	if err != nil {
		return err
	}
	return err
}

// 统计电脑使用的记录
func (s *LogicalLog) SetComputerCache(ctx context.Context, date string, pcCode, operator string) (err error) {
	key := fmt.Sprintf(ComputerCacheKey, date)
	_, err = global.GVA_REDIS.HSet(ctx, key, pcCode, operator).Result()
	if err != nil {
		return err
	}
	return err
}

// 获取统计电脑使用的记录
func (s *LogicalLog) GetComputerCache(ctx context.Context, date string) (mps map[string]string, err error) {
	key := fmt.Sprintf(ComputerCacheKey, date)
	mps, err = global.GVA_REDIS.HGetAll(ctx, key).Result()
	if err != nil {
		return mps, err
	}
	return mps, err
}

// 统计电脑拉取账号的数量
func (s *LogicalLog) SetComputerPullAccountNumCache(ctx context.Context, date string, pcCode string, gameId int) (err error) {
	key := fmt.Sprintf(ComputerPullAccountCacheKey, date, pcCode) + strconv.Itoa(gameId)
	err = s.cache.SetCacheNum(ctx, key)
	return err
}

// 获取统计电脑拉取账号的数量
func (s *LogicalLog) GetComputerPullAccountNumCache(ctx context.Context, date string, pcCode string) (mps map[string]int, err error) {
	key := fmt.Sprintf(ComputerPullAccountCacheKey, date, pcCode)
	mps, err = s.GetByPcCodeGameNumCache(ctx, key)
	if len(mps) == 0 {
		return
	}
	return
}

// 统计电脑进入主线的数量
func (s *LogicalLog) SetComputerEnterMainNumCache(ctx context.Context, date string, pcCode string, gameId int) (err error) {
	key := fmt.Sprintf(ComputerEnterMainCacheKey, date, pcCode) + strconv.Itoa(gameId)
	err = s.cache.SetCacheNum(ctx, key)
	return err
}

// 获取统计电脑进入主线的数量
func (s *LogicalLog) GetComputerEnterMainNumCache(ctx context.Context, date string, pcCode string) (mps map[string]int, err error) {
	key := fmt.Sprintf(ComputerEnterMainCacheKey, date, pcCode)
	mps, err = s.GetByPcCodeGameNumCache(ctx, key)
	if len(mps) == 0 {
		return
	}
	return
}

// 统计电脑任务成功的数量
func (s *LogicalLog) SetComputerTaskSuccessNumCache(ctx context.Context, date string, pcCode string, gameId int) (err error) {
	key := fmt.Sprintf(ComputerTaskSuccessCacheKey, date, pcCode) + strconv.Itoa(gameId)
	err = s.cache.SetCacheNum(ctx, key)
	return err
}

// 获取统计电脑任务成功的数量
func (s *LogicalLog) GetComputerTaskSuccessNumCache(ctx context.Context, date string, pcCode string) (mps map[string]int, err error) {
	key := fmt.Sprintf(ComputerTaskSuccessCacheKey, date, pcCode)
	mps, err = s.GetByPcCodeGameNumCache(ctx, key)
	if len(mps) == 0 {
		return
	}
	return
}

// 通过电脑code获取游戏缓存的数量
func (s *LogicalLog) GetByPcCodeGameNumCache(ctx context.Context, key string) (mps map[string]int, err error) {
	key += "*"
	data, err := s.cache.GetCacheKeys(ctx, key)
	if len(data) == 0 {
		return
	}
	mps = make(map[string]int)
	for _, k := range data {
		gameId := s.ByCacheKeyGetEndNode(k)
		num, _ := s.cache.GetCacheNum(ctx, k)
		mps[gameId] = num
	}
	return
}

// 统计游戏付费效率的预埋数据
func (s *LogicalLog) StatisticsFeeRateData(ctx context.Context, gameId int, logUuid string) {
	key := fmt.Sprintf(GameFeeRateCacheKey, s.CurrentDate(), gameId)
	z := &redis.Z{
		Member: logUuid,
		Score:  float64(time.Now().UnixNano() / 1e6),
	}
	global.GVA_REDIS.ZAdd(ctx, key, z)
}

// 获取统计游戏付费效率的数量
func (s *LogicalLog) GetStatisticsFeeRate(ctx context.Context, gameId int) (num int) {
	key := fmt.Sprintf(GameFeeRateCacheKey, s.CurrentDate(), gameId)
	z, err := global.GVA_REDIS.ZRangeWithScores(ctx, key, -1, -1).Result()
	if err != nil {
		return
	}
	if len(z) == 0 {
		return
	}
	end := z[0].Score
	start := z[0].Score - 30*60*1000
	op := redis.ZRangeBy{
		Min: strconv.Itoa(int(start)),
		Max: strconv.Itoa(int(end)),
	}
	i, err := global.GVA_REDIS.ZRangeByScore(ctx, key, &op).Result()
	if err != nil {
		return
	}
	num = len(i)
	return
}

// 获取统计单台电脑单个游戏付费效率的预埋数据
func (s *LogicalLog) GetStatisticsPcFeeRate(ctx context.Context, pcCode string, gameId int) (num int) {
	key := fmt.Sprintf(GamePcFeeRateCacheKey, s.CurrentDate(), gameId, pcCode)
	z, err := global.GVA_REDIS.ZRangeWithScores(ctx, key, -1, -1).Result()
	if err != nil {
		return
	}
	if len(z) == 0 {
		return
	}
	end := z[0].Score
	start := z[0].Score - 30*60*1000
	op := redis.ZRangeBy{
		Min: strconv.Itoa(int(start)),
		Max: strconv.Itoa(int(end)),
	}
	i, err := global.GVA_REDIS.ZRangeByScore(ctx, key, &op).Result()
	if err != nil {
		return
	}
	num = len(i)
	return
}

// 统计单台电脑单个游戏付费效率的预埋数据
func (s *LogicalLog) StatisticsPcFeeRateData(ctx context.Context, pcCode string, logUuid string, gameId int) {
	key := fmt.Sprintf(GamePcFeeRateCacheKey, s.CurrentDate(), gameId, pcCode)
	z := &redis.Z{
		Member: logUuid,
		Score:  float64(time.Now().UnixNano() / 1e6),
	}
	global.GVA_REDIS.ZAdd(ctx, key, z)
}

// 统计电脑效率的预埋数据
func (s *LogicalLog) StatisticsComputerRateData(ctx context.Context, pcCode string, gameId int) (err error) {
	hour := time.Now().Hour()
	key := fmt.Sprintf(GameComputerRateCacheKey, s.CurrentDate(), pcCode)
	key = key + strconv.Itoa(hour)
	err = s.cache.SetCacheStr(ctx, key, gameId)
	return
}

// 统计电脑效率的预埋数据
func (s *LogicalLog) GetStatisticsComputerRate(ctx context.Context, pcCode string) (num int) {
	key := fmt.Sprintf(GameComputerRateCacheKey, s.CurrentDate(), pcCode)
	key = key + "*"
	data, _ := s.cache.GetCacheKeys(ctx, key)
	h := map[string]int{
		"2": 1,
		"3": 1,
		"4": 1,
		"5": 1,
		"6": 1,
		"7": 1,
		"8": 1,
	}
	var i = 0
	for _, v := range data {
		key := strings.Split(v, ":")
		hr := key[len(key)-1:][0]
		if _, ok := h[hr]; ok {
			continue
		}
		i++
	}
	hour := time.Now().Hour()
	//num = hour + 1 - len(data)
	if hour >= 8 {
		num = hour + 1 - 7 - i
	} else {
		notCalculated := hour - 2
		num = hour + 1 - notCalculated - i
	}
	return
}

// 请求机房任务数据
func (s *LogicalLog) RequestJfRoom() (result []byte, err error) {
	today := time.Now().Format("2006-01-02")
	jfurl := "http://xjf.lianyou.fun:8099/v1/task_statistics"
	jfparams := map[string]string{
		"query": "date:" + today + ",type:machine",
	}
	result, err = utils.HttpGet(jfurl, jfparams)
	return
}

// 请求机房数据接口数据
func (s *LogicalLog) RequestTaskData() (result []byte, err error) {
	today := time.Now().Format("2006-01-02")
	jfurl := "http://xjf.lianyou.fun:8118/data/taskDateLog"
	jfparams := map[string]string{
		"date": today,
	}
	result, err = utils.HttpGet(jfurl, jfparams)
	return
}

// 统计在线电脑数据
func (s *LogicalLog) SetOnlineComputerNumCache(ctx context.Context, date string, pcCode string, operator string) (err error) {
	key := fmt.Sprintf(OnLineComputerNum, date)
	key += pcCode
	err = s.cache.SetCacheStr(ctx, key, operator)
	return err
}

// 获取在线电脑数据
func (s *LogicalLog) GetOnlineComputerNumCache(ctx context.Context, date string) (mps map[string]string, err error) {
	key := fmt.Sprintf(OnLineComputerNum, date)
	mps, err = s.GetAllOnlineComputerNumCache(ctx, key)
	if len(mps) == 0 {
		return
	}
	return
}

// 获取所有在线电脑
func (s *LogicalLog) GetAllOnlineComputerNumCache(ctx context.Context, key string) (mps map[string]string, err error) {
	key += "*"
	data, err := s.cache.GetCacheKeys(ctx, key)
	if len(data) == 0 {
		return
	}
	mps = make(map[string]string)
	for _, k := range data {
		pcCode := s.ByCacheKeyGetEndNode(k)
		operator, _ := s.cache.GetCacheStr(ctx, k)
		mps[pcCode] = operator
	}
	return
}

// 获取电脑2小时内上报的次数
func (s *LogicalLog) GetPcReportingLog(ctx context.Context, pcCode string) (num int) {
	key := fmt.Sprintf(PcReportingLog, s.CurrentDate(), pcCode)
	z, err := global.GVA_REDIS.ZRangeWithScores(ctx, key, -1, -1).Result()
	if err != nil {
		return
	}
	if len(z) == 0 {
		return
	}
	end := time.Now().UnixNano()/1e6 + 60*1000*2
	start := end - (60*60*1000 + 60*1000*4)
	op := redis.ZRangeBy{
		Min: strconv.Itoa(int(start)),
		Max: strconv.Itoa(int(end)),
	}
	i, err := global.GVA_REDIS.ZRangeByScore(ctx, key, &op).Result()
	if err != nil {
		return
	}
	num = len(i)
	return
}

// 获取电脑上报的次数
func (s *LogicalLog) CheckPcReportingLog(ctx context.Context, pcCode string, timeInterval int64) (num int) {
	key := fmt.Sprintf(PcReportingLog, s.CurrentDate(), pcCode)
	z, err := global.GVA_REDIS.ZRangeWithScores(ctx, key, -1, -1).Result()
	if err != nil {
		return
	}
	if len(z) == 0 {
		return
	}
	end := time.Now().UnixNano()/1e6 + 60*1000*2
	start := end - timeInterval
	op := redis.ZRangeBy{
		Min: strconv.Itoa(int(start)),
		Max: strconv.Itoa(int(end)),
	}
	i, err := global.GVA_REDIS.ZRangeByScore(ctx, key, &op).Result()
	if err != nil {
		return
	}
	num = len(i)
	return
}

// 添加电脑定时上报记录
func (s *LogicalLog) SetPcReportingLog(ctx context.Context, pcCode string, operator string) {
	key := fmt.Sprintf(PcReportingLog, s.CurrentDate(), pcCode)
	z := &redis.Z{
		Member: operator,
		Score:  float64(time.Now().UnixNano() / 1e6),
	}
	global.GVA_REDIS.ZAdd(ctx, key, z)
}

// 删除hash缓存数据
func (s *LogicalLog) DelHashKey(ctx context.Context, date string) {
	gameKeys := fmt.Sprintf(GameCacheKey, date)
	data, _ := global.GVA_REDIS.HKeys(ctx, gameKeys).Result()
	global.GVA_REDIS.HDel(ctx, gameKeys, data...)
	logUuidAccountGameId := fmt.Sprintf(logUuidAccountGameId, date)
	logUuid, _ := global.GVA_REDIS.HKeys(ctx, logUuidAccountGameId).Result()
	global.GVA_REDIS.HDel(ctx, logUuidAccountGameId, logUuid...)
	taskStatisticsKey := fmt.Sprintf("%s:taskStatistics", date)
	taskStatistics, _ := global.GVA_REDIS.HKeys(ctx, taskStatisticsKey).Result()
	global.GVA_REDIS.HDel(ctx, taskStatisticsKey, taskStatistics...)
	computerListKey := fmt.Sprintf(ComputerCacheKey, date)
	computerListKeys, _ := global.GVA_REDIS.HKeys(ctx, computerListKey).Result()
	global.GVA_REDIS.HDel(ctx, computerListKey, computerListKeys...)
}

// 删除ZSet缓存数据
func (s *LogicalLog) DelZSetKey(ctx context.Context, date string) {
	gamePcKey := fmt.Sprintf("%s:gamePc:gameFeeRate*", date)
	gameKey := fmt.Sprintf("%s:game:gameFeeRate*", date)
	pcReportingKey := fmt.Sprintf("%s:pc:Reporting:*", date)
	beginTime, _ := time.ParseInLocation("2006-01-02", date, time.Local)
	beginTimeI := strconv.Itoa(int(beginTime.Unix() * 1000))
	endTime := strconv.Itoa(int(beginTime.Unix()*1000 + 24*60*60*1000))
	gamePcKeys, _ := global.GVA_REDIS.Keys(ctx, gamePcKey).Result()
	gameKeys, _ := global.GVA_REDIS.Keys(ctx, gameKey).Result()
	pcReportingKeys, _ := global.GVA_REDIS.Keys(ctx, pcReportingKey).Result()
	for _, k := range gamePcKeys {
		global.GVA_REDIS.ZRemRangeByScore(ctx, k, beginTimeI, endTime)
	}
	for _, k := range gameKeys {
		global.GVA_REDIS.ZRemRangeByScore(ctx, k, beginTimeI, endTime)
	}
	for _, k := range pcReportingKeys {
		global.GVA_REDIS.ZRemRangeByScore(ctx, k, beginTimeI, endTime)
	}
}

// 删除hashUuid缓存数据
func (s *LogicalLog) DelHashUuidKey(ctx context.Context, date string) {
	gameIds, _ := s.GetGameCache(ctx, date)
	for id, _ := range gameIds {
		gamekeys := fmt.Sprintf("%s:logUuid:%s:*", date, id)
		data, _ := global.GVA_REDIS.Keys(ctx, gamekeys).Result()
		for _, hkey := range data {
			value, _ := global.GVA_REDIS.HKeys(ctx, hkey).Result()
			global.GVA_REDIS.HDel(ctx, hkey, value...)
		}
	}
}

// 记录扫码订单号信息
func (s *LogicalLog) AddCodeLog(request request.AddLogRequest, status int) {
	if request.Remarks == "" {
		return
	}
	logSC := new(log.LogScanningCode)
	logSC.GameId = request.GameId
	logSC.LogUuid = request.LogUuid
	logSC.TaskType = request.TaskType
	logSC.Status = status
	if logSC.Status == 0 {
		logSC.Status = -1
	}
	codeSupplier := strings.Split(request.Remarks, "|")
	logSC.OrderNum = codeSupplier[0]
	logSC.Supplier = codeSupplier[1]
	logSC.CreateDate = time.Now()
	err := global.GVA_DB.Omit("create_time").Create(&logSC).Error
	if err != nil {
		global.GVA_LOG.Error("create LogScanningCode fail", zap.Error(err))
	}
}

// 记录ip信息
func (s *LogicalLog) AddIpLog(request request.AddLogRequest) {
	if request.SimulatorIp == "" {
		return
	}
	logSC := new(log.IpLog)
	logSC.GameId = request.GameId
	logSC.LogUuid = request.LogUuid
	logSC.Ip = request.SimulatorIp
	logSC.Account = request.Account
	logSC.PcCode = request.PcCode
	logSC.CreateDate = time.Now().Format("2006-01-02")
	err := global.GVA_DB.Omit("create_time").Create(&logSC).Error
	if err != nil {
		global.GVA_LOG.Error("create LogScanningCode fail", zap.Error(err))
	}
}

// 进入游戏ip信息
func (s *LogicalLog) UpdateIpLogStatus(logUuid string, createDate string) {
	err := global.GVA_DB.Table("ip_log").Where("create_date = ?", createDate).Where("log_uuid = ?", logUuid).Update("status", 2).Error
	if err != nil {
		global.GVA_LOG.Error("create LogScanningCode fail", zap.Error(err))
	}
}

// 记录设备信息
func (s *LogicalLog) AddDeviceLog(request request.AddLogRequest) {

	logSC := new(log.DeviceLog)
	logSC.GameId = request.GameId
	logSC.LogUuid = request.LogUuid
	logSC.Account = request.Account
	logSC.DeviceId = request.DeviceId
	logSC.DeviceImei = request.DeviceImei
	logSC.DeviceIp = request.SimulatorIp
	logSC.DeviceMac = request.DeviceMac
	logSC.DeviceManufacturer = request.DeviceManufacturer
	logSC.DeviceModel = request.DeviceModel
	logSC.DeviceSdk = request.DeviceSdk
	logSC.DeviceNumber = request.DeviceNumber
	logSC.SimulatorCode = request.SimulatorCode
	logSC.IsErr = -1
	logSC.ErrStatus = 1
	logSC.DeviceHex = s.DeviceHexLog(request)
	logSC.AccountHex = s.AccountHexLog(request)
	logSC.CreateDate = time.Now().Format("2006-01-02")
	logSC.PcCode = request.PcCode
	logSC.SimulatorIpCity = request.SimulatorIpCity
	ctx := context.Background()
	if s.CheckDeviceLogIsSave(logSC) {
		logSC.IsErr = 1
		logSC.ErrStatus = 4
		logSC.CreateDate = time.Now().Format("2006-01-02")
		err := global.GVA_DB.Omit("create_time").Create(&logSC).Error
		if err != nil {
			global.GVA_LOG.Error("create LogScanningCode fail", zap.Error(err))
		}
		return
	}
	var deviceLogs []log.DeviceErr
	if request.TaskType == 1 {
		global.GVA_DB.Table("game_account").Where("account = ?", request.Account).Where("game_id = ?", request.GameId).Order("id desc").Limit(1).Find(&deviceLogs)
		if len(deviceLogs) != 0 {
			if deviceLogs[0].AccountHex != "" && deviceLogs[0].AccountHex != logSC.AccountHex {
				logSC.IsErr = 1
				logSC.ErrStatus = 3
				gameDeviceErrKey := fmt.Sprintf(GameDeviceErrKey, logSC.CreateDate, request.GameId)
				s.cache.SetCacheNum(ctx, gameDeviceErrKey)
			}
		}
	} else {
		if !errors.Is(global.GVA_DB.Table("game_account").Where("game_id = ?", request.GameId).Where("account != ?", request.Account).Where("device_hex = ?", logSC.DeviceHex).Order("id desc").Limit(10).Find(&deviceLogs).Error, gorm.ErrRecordNotFound) {
			if len(deviceLogs) > 2 {
				logSC.IsErr = 1
				logSC.ErrStatus = 2
				gameDeviceAccountErrKey := fmt.Sprintf(GameDeviceAccountErrKey, logSC.CreateDate, request.GameId)
				s.cache.SetCacheNum(ctx, gameDeviceAccountErrKey)
			}
		}
	}
	logSC.CreateDate = time.Now().Format("2006-01-02")
	err := global.GVA_DB.Omit("create_time").Create(&logSC).Error
	if err != nil {
		global.GVA_LOG.Error("create LogScanningCode fail", zap.Error(err))
	}
	if logSC.ErrStatus == 3 || logSC.ErrStatus == 2 {
		s.AddDeviceErr(logSC, deviceLogs)
	}
}

func (s *LogicalLog) AddDeviceErr(deviceLog *log.DeviceLog, deviceErrs []log.DeviceErr) {
	var deviceErr = log.DeviceErr{}
	deviceErr.GameId = deviceLog.GameId
	deviceErr.ScriptDeviceId = deviceLog.ScriptDeviceId
	deviceErr.Account = deviceLog.Account
	deviceErr.DeviceId = deviceLog.DeviceId
	deviceErr.DeviceImei = deviceLog.DeviceImei
	deviceErr.DeviceMac = deviceLog.DeviceMac
	deviceErr.DeviceManufacturer = deviceLog.DeviceManufacturer
	deviceErr.DeviceModel = deviceLog.DeviceModel
	deviceErr.DeviceSdk = deviceLog.DeviceSdk
	deviceErr.DeviceNumber = deviceLog.DeviceNumber
	deviceErr.AccountHex = deviceLog.AccountHex
	deviceErr.DeviceHex = deviceLog.DeviceHex
	deviceErr.CreateTime = time.Now()
	deviceErrs = append(deviceErrs, deviceErr)
	for k, _ := range deviceErrs {
		deviceErrs[k].DeviceLogId = deviceLog.Id
		deviceErrs[k].CreateDate = time.Now()
	}
	err := global.GVA_DB.Table("device_err").Omit("id").Create(&deviceErrs).Error
	if err != nil {
		global.GVA_LOG.Error("create AddAccount fail", zap.Error(err))
	}
}

func (s *LogicalLog) CheckDeviceLogIsSave(deviceLog *log.DeviceLog) bool {
	return deviceLog.DeviceManufacturer == "" || deviceLog.DeviceModel == "" || deviceLog.DeviceImei == "" || deviceLog.DeviceSdk == "" || deviceLog.DeviceMac == "" || deviceLog.DeviceNumber == "" || deviceLog.DeviceId == ""
}

func (s *LogicalLog) DeviceHexLog(request request.AddLogRequest) string {
	logSC := new(log.DeviceHex)
	logSC.GameId = request.GameId
	logSC.DeviceId = request.DeviceId
	logSC.DeviceImei = request.DeviceImei
	logSC.DeviceMac = request.DeviceMac
	logSC.DeviceManufacturer = request.DeviceManufacturer
	logSC.DeviceModel = request.DeviceModel
	logSC.DeviceSdk = request.DeviceSdk
	logSC.DeviceNumber = request.DeviceNumber
	dh, _ := json.Marshal(logSC)
	return utils.ByteToHex(dh)
}

func (s *LogicalLog) AccountHexLog(request request.AddLogRequest) string {
	logSC := new(log.AccountHex)
	logSC.GameId = request.GameId
	logSC.DeviceId = request.DeviceId
	logSC.DeviceImei = request.DeviceImei
	logSC.DeviceMac = request.DeviceMac
	logSC.DeviceManufacturer = request.DeviceManufacturer
	logSC.DeviceModel = request.DeviceModel
	logSC.DeviceSdk = request.DeviceSdk
	logSC.DeviceNumber = request.DeviceNumber
	logSC.Account = request.Account
	dh, _ := json.Marshal(logSC)
	return utils.ByteToHex(dh)
}

// 修改设备信息状态
func (s *LogicalLog) UpdateDeviceLogStatus(logUuid string, createDate string) {
	err := global.GVA_DB.Table("device_log").Where("create_date = ?", createDate).Where("log_uuid = ?", logUuid).Update("status", 1).Error
	if err != nil {
		global.GVA_LOG.Error("update UpdateDeviceLogStatus fail", zap.Error(err))
	}
}

// 修改设备信息状态
func (s *LogicalLog) UpdateDeviceLogScriptId(logUuid string, scriptDeviceId string, createDate string) {
	err := global.GVA_DB.Table("device_log").Where("create_date = ?", createDate).Where("log_uuid = ?", logUuid).Update("script_device_id", scriptDeviceId).Update("status", 1).Error
	if err != nil {
		global.GVA_LOG.Error("create LogScanningCode fail", zap.Error(err))
	}
}

func (s *LogicalLog) AddAccount(request request.AddLogRequest, deviceLog log.DeviceLog) {
	gameAccount := new(log.GameAccount)
	gameAccount.GameId = request.GameId
	gameAccount.ScriptDeviceId = request.ScriptDeviceId
	gameAccount.Account = request.Account
	if deviceLog.ErrStatus != 4 {
		gameAccount.DeviceId = deviceLog.DeviceId
		gameAccount.DeviceImei = deviceLog.DeviceImei
		gameAccount.DeviceMac = deviceLog.DeviceMac
		gameAccount.DeviceManufacturer = deviceLog.DeviceManufacturer
		gameAccount.DeviceModel = deviceLog.DeviceModel
		gameAccount.DeviceSdk = deviceLog.DeviceSdk
		gameAccount.DeviceNumber = deviceLog.DeviceNumber
		gameAccount.AccountHex = deviceLog.AccountHex
		gameAccount.DeviceHex = deviceLog.DeviceHex
	}
	err := global.GVA_DB.Omit("create_time", "update_time", "use_num").Create(&gameAccount).Error
	if err != nil {
		global.GVA_LOG.Error("create AddAccount fail", zap.Error(err))
	}
}

func (s *LogicalLog) AddScriptDeviceErr(gameId int, account, firstDeviceId, currentDeviceId string, firstAccount string, firstGameId int, status uint, pcCode string, operator string) {
	scriptDeviceErr := new(log.ScriptDeviceErr)
	scriptDeviceErr.GameId = firstGameId
	scriptDeviceErr.Account = firstAccount
	scriptDeviceErr.CurrentAccount = account
	scriptDeviceErr.CurrentGameId = gameId
	scriptDeviceErr.FirstDeviceId = firstDeviceId
	scriptDeviceErr.CurrentDeviceId = currentDeviceId
	scriptDeviceErr.CreateDate = time.Now().Format("2006-01-02")
	scriptDeviceErr.Status = status
	scriptDeviceErr.PcCode = pcCode
	scriptDeviceErr.Operator = operator
	err := global.GVA_DB.Omit("create_time").Create(&scriptDeviceErr).Error
	if err != nil {
		global.GVA_LOG.Error("create AddScriptDeviceErr fail", zap.Error(err))
	}
}

func (s *LogicalLog) CheckDeviceId(request request.AddLogRequest) {
	if request.ScriptDeviceId == "" {
		// 通知异常逻辑
		global.GVA_LOG.Error("get CheckDeviceId fail", zap.Error(errors.New("没有获取到设备id")))
		return
	}
	date := time.Now().Format("2006-01-02")
	s.UpdateDeviceLogScriptId(request.LogUuid, request.ScriptDeviceId, date)
	var device log.DeviceLog
	global.GVA_DB.Table("device_log").Where("create_date = ?", date).Where("log_uuid = ?", request.LogUuid).First(&device)
	global.GVA_LOG.Warn("进入 CheckDeviceId")
	if request.TaskType == 0 {
		b, deviceLog := s.CheckDeviceIdErr(request.ScriptDeviceId, request.LogUuid, request.GameId)
		// 有异常处理
		if b && len(deviceLog) >= 3 {
			s.AddScriptDeviceErr(request.GameId, request.Account, request.ScriptDeviceId, request.ScriptDeviceId, deviceLog[0].Account, deviceLog[0].GameId, 2, request.PcCode, request.Operator)
			//ct := fmt.Sprintf("<font color=\"warning\">%s:%d, 相同设备id</font>", request.PcCode, request.GameId)
			//s.SendDeviceMsg(ct, request.Operator)
		}
		s.AddAccount(request, device)
		return
	}
	var gameAccount log.GameAccount
	result := global.GVA_DB.Where("game_id = ?", request.GameId).Where("account = ?", request.Account).First(&gameAccount)
	if result.Error != nil {
		if result.Error == gorm.ErrRecordNotFound {
			// 数据不存在，执行创建操作
			s.AddAccount(request, device)
			return
		} else {
			// 其他错误
			global.GVA_LOG.Error("Select GameAccount fail", zap.Error(result.Error))
			return
		}
	}
	if gameAccount.ScriptDeviceId != request.ScriptDeviceId || device.ErrStatus == 3 || gameAccount.DeviceHex == "" {
		s.AddScriptDeviceErr(request.GameId, request.Account, gameAccount.ScriptDeviceId, request.ScriptDeviceId, gameAccount.Account, gameAccount.GameId, 1, request.PcCode, request.Operator)
		//ct := fmt.Sprintf("<font color=\"warning\">%s:%d, 设备id出现不同</font>", request.PcCode, request.GameId)
		//s.SendDeviceMsg(ct, request.Operator)
		gameAccount.ScriptDeviceId = request.ScriptDeviceId
		if gameAccount.DeviceHex != device.DeviceHex {
			gameAccount.DeviceId = device.DeviceId
			gameAccount.DeviceImei = device.DeviceImei
			gameAccount.DeviceMac = device.DeviceMac
			gameAccount.DeviceManufacturer = device.DeviceManufacturer
			gameAccount.DeviceModel = device.DeviceModel
			gameAccount.DeviceSdk = device.DeviceSdk
			gameAccount.DeviceNumber = device.DeviceNumber
			gameAccount.AccountHex = device.AccountHex
			gameAccount.DeviceHex = device.DeviceHex
		}
	}
	gameAccount.UseNum += 1
	global.GVA_DB.Save(&gameAccount)
}

func (s *LogicalLog) SendDeviceMsg(content string, operator string) {
	c := "# 设备异常"
	c += "\n"
	ct := content
	ct = c + ct
	fmt.Println(ct)
	mpsPerson, _ := s.Person.GetUserInfoData()
	if operator != "" {
		s.SendContent(ct, mpsPerson[operator].Url)
		url := global.GVA_CONFIG.SendUrl.ComputerSendUrl
		s.SendContent(ct, url)
		var sendTextData SendTextMsg
		sendTextData.MsgType = "text"
		sendTextData.Text.MentionedMobileList = []string{mpsPerson[operator].MobilePhoneNumber}
		_, _ = s.SendMsgData(url, sendTextData)
	}
}

type SendMsg struct {
	MsgType  string `json:"msgtype"`
	Markdown struct {
		Content string `json:"content"`
	} `json:"markdown"`
}

type SendTextMsg struct {
	MsgType string `json:"msgtype"`
	Text    struct {
		MentionedMobileList []string `json:"mentioned_mobile_list"`
	} `json:"text"`
}

func (s *LogicalLog) SendContent(content, url string) {
	var sendMsg SendMsg
	sendMsg.MsgType = "markdown"
	sendMsg.Markdown.Content = content
	_, _ = s.SendMsgData(url, sendMsg)
}

func (s *LogicalLog) SendMsgData(url string, params interface{}) (result []byte, err error) {
	result, err = utils.HttpPost(url, params)
	return
}

func (s *LogicalLog) CheckDeviceIdErr(scriptDeviceId string, uuid string, gameId int) (bool, []log.GameAccount) {
	var deviceLog []log.GameAccount
	// result := global.GVA_DB.Where("create_date <= ?", time.Now().Format("2006-01-02")).Where("create_date >= ?", time.Now().Add(-time.Hour*24).Format("2006-01-02")).Where("game_id = ?", gameId).Where("script_device_id = ?", scriptDeviceId).Find(&deviceLog)
	result := global.GVA_DB.Where("game_id = ?", gameId).Where("script_device_id = ?", scriptDeviceId).Find(&deviceLog)
	if result.Error != nil {
		if result.Error == gorm.ErrRecordNotFound {
			return false, deviceLog
		}
	}
	return true, deviceLog
}

func (s *LogicalLog) AddDeviceErrLog(request request.AddLogRequest, st uint) {
	if request.Err == "" {
		return
	}
	ctx := context.Background()
	key := fmt.Sprintf(GameDeviceUuidKey, time.Now().Format("2006-01-02"), request.LogUuid)
	status, _ := s.ExistsKey(ctx, key)
	if status {
		return
	}
	errLog := new(log.DeviceErrLog)
	errLog.GameId = request.GameId
	errLog.CreateDate = time.Now()
	errLog.CreateTime = time.Now()
	errLog.Err = request.Err
	errLog.PcCode = request.PcCode
	content, _ := json.Marshal(request)
	errLog.Content = string(content)
	errLog.Status = st
	err := errLog.Create()
	if err != nil {
		global.GVA_LOG.Error("create AddAccount fail", zap.Error(err))
		return
	}
	global.GVA_REDIS.Set(ctx, key, 1, time.Hour)
}