RoServer/RO_Server_Trunk-branch_bt/roserver/db/model/orm_activity.go

package model

import (
	"rocommon/service"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/serverproto"
	"strconv"
)

const (
	RoleActivityDataSignPrefix = "role_activity_sign_" //基础结构数据
	//当前开放的活动列表
	RoleActivityDataOpenListPrefix = "role_activity_openlist_"

	//砸蛋大奖消息
	RoleActivitySmashEggsPrefix = "role_activity_smasheggs_"
)

func GetRoleActivityDataFromRedis(uid uint64, roleActivity *serverproto.RoleActivity) error {
	err := GetSystemDataFromRedis(RoleActivityDataSignPrefix, uid, roleActivity)
	if err != nil && err != service.NIL {
		util.InfoF("uid=%v GetRoleFromRedis RoleActivitySign err=%v", uid, err)
		return err
	}

	uidStr := strconv.FormatUint(uid, 10)
	//过期删除的活动是否误操作
	nowTimeMs := util.GetTimeMilliseconds()
	var tmpExpiredActivityList []int32
	bChange := false
	for idx := 0; idx < len(roleActivity.ExpiredActivityList); idx++ {
		expiredActivityId := roleActivity.ExpiredActivityList[idx]
		activityIdStr := strconv.Itoa(int(expiredActivityId))
		//base data
		detailData := &serverproto.ActivitiesDetailData{}
		tmpKeyStr := RoleActivityDataPrefix + uidStr + ":" + activityIdStr
		baseStr, err1 := service.GetRedis().HGet(tmpKeyStr, "base").Result()
		if err1 != nil {
			util.InfoF("uid=%v GetRoleFromRedis RoleActivity base err=%v", tmpKeyStr, err)
			tmpExpiredActivityList = append(tmpExpiredActivityList, expiredActivityId)
			continue
		}
		model.GetDecodeMessage(detailData, baseStr)
		if detailData.EndTime <= nowTimeMs {
			tmpExpiredActivityList = append(tmpExpiredActivityList, expiredActivityId)
		} else {
			bChange = true
			//没有过期重新放入开启列表中
			//添加到开启活动列表中
			if !service.GetRedis().SIsMember(RoleActivityDataOpenListPrefix+uidStr, activityIdStr).Val() {
				service.GetRedis().SAdd(RoleActivityDataOpenListPrefix+uidStr, activityIdStr)
			}
		}
	}
	if bChange {
		//重新保存
		roleActivity.ExpiredActivityList = tmpExpiredActivityList
		err := SetSystemDataToRedis(RoleActivityDataSignPrefix, uid, roleActivity)
		if err != nil {
			util.InfoF("uid=%v SSActivityDataSaveReqSign save err=%v", uid, err)
		}
	}

	//砸蛋大奖消息获取
	smashEggsMsg := &serverproto.SSActivitySmashEggsMsgSaveNtf{}
	err = model.GetMessageFromRedis(RoleActivitySmashEggsPrefix, "", smashEggsMsg)
	if err == nil {
		roleActivity.ActMsgList = smashEggsMsg.ActMsgList
	}

	//正常流程处理
	retList := service.GetRedis().SMembers(RoleActivityDataOpenListPrefix + uidStr).Val()
	for idx := 0; idx < len(retList); idx++ {
		openActivityId, _ := strconv.Atoi(retList[idx])
		if openActivityId <= 0 {
			service.GetRedis().SRem(RoleActivityDataOpenListPrefix+uidStr, retList[idx])
			continue
		}

		//base data
		detailData := &serverproto.ActivitiesDetailData{}
		tmpKeyStr := RoleActivityDataPrefix + uidStr + ":" + retList[idx]
		baseStr, err1 := service.GetRedis().HGet(tmpKeyStr, "base").Result()
		if err1 != nil {
			util.InfoF("uid=%v GetRoleFromRedis RoleActivity base err=%v", tmpKeyStr, err)
			continue
		}
		model.GetDecodeMessage(detailData, baseStr)
		detailData.ActivitiesId = int32(openActivityId)
		//task data
		retList := service.GetRedis().HGetAll(tmpKeyStr).Val()
		for filedStr, msgStr := range retList {
			if filedStr == "base" {
				continue
			}
			if detailData.ActivitiesType == int32(serverproto.EActivityType_EActivityType_14_Days_Task) {
				if detailData.FortnightDays == nil {
					detailData.FortnightDays = &serverproto.ActivitiesFortnightDays{}
				}
				taskInfo := &serverproto.TaskData{}
				err = model.GetDecodeMessage(taskInfo, msgStr)
				if err == nil {
					detailData.FortnightDays.TaskList = append(detailData.FortnightDays.TaskList, taskInfo)
				}
			} else if detailData.ActivitiesType == int32(serverproto.EActivityType_EActivityType_King) {
				taskInfo := &serverproto.TaskData{}
				err = model.GetDecodeMessage(taskInfo, msgStr)
				if err == nil {
					detailData.KingTask = append(detailData.KingTask, taskInfo)
				}
			} else if detailData.ActivitiesType == int32(serverproto.EActivityType_EActivityType_BT_ROCoinRecharge) {
				//BT task data
				if detailData.BtRocoinData == nil {
					detailData.BtRocoinData = &serverproto.ActivityBTROCoin{}
				}
				taskInfo := &serverproto.TaskData{}
				err = model.GetDecodeMessage(taskInfo, msgStr)
				if err == nil {
					if taskInfo.TaskType == int32(model.BTTaskRefreshType_Day) {
						detailData.BtRocoinData.DailyTaskList = append(detailData.BtRocoinData.DailyTaskList, taskInfo)
					} else if taskInfo.TaskType == int32(model.BTTaskRefreshType_Week) {
						detailData.BtRocoinData.WeekTaskList = append(detailData.BtRocoinData.WeekTaskList, taskInfo)
					}
				}
			} else if detailData.ActivitiesType == int32(serverproto.EActivityType_EActivityType_BT_ZhenJiaRecharge) {
				// BT task data
				taskInfo := &serverproto.TaskData{}
				err = model.GetDecodeMessage(taskInfo, msgStr)
				if err == nil {
					detailData.BtZhenjiaRechargeTaskList = append(detailData.BtZhenjiaRechargeTaskList, taskInfo)
				}
			}

		}

		roleActivity.ActivityDataList = append(roleActivity.ActivityDataList, detailData)
	}

	return nil
}

func SetRoleActivityDataToRedis(uid uint64, msg *serverproto.SSActivityDataSaveReq) {
	err := SetSystemDataToRedis(RoleActivityDataSignPrefix, uid, msg.RoleActivity)
	if err != nil {
		util.InfoF("uid=%v SSActivityDataSaveReqSign save err=%v", uid, err)
	}

	//role_activity_[uid]:[activityId]
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RoleActivityDataPrefix + uidStr
	for idx := 0; idx < len(msg.DelActivityList); idx++ {
		activityIdStr := strconv.Itoa(int(msg.DelActivityList[idx]))
		//service.GetRedis().Del(keyStr + ":" + activityIdStr) 删除列表但是不删除原始数据，供查询使用

		service.GetRedis().SRem(RoleActivityDataOpenListPrefix+uidStr, activityIdStr)
	}

	for idx := 0; idx < len(msg.ChangeActivityList); idx++ {
		tmpData := msg.ChangeActivityList[idx]
		activityIdStr := strconv.Itoa(int(tmpData.ActivitiesId))
		tmpKeyStr := keyStr + ":" + activityIdStr

		//添加到开启活动列表中
		if !service.GetRedis().SIsMember(RoleActivityDataOpenListPrefix+uidStr, activityIdStr).Val() {
			service.GetRedis().SAdd(RoleActivityDataOpenListPrefix+uidStr, activityIdStr)
		}

		//活动本身基础数据(有时候基础数据不变)
		if tmpData.ActivityData != nil {
			errBase, msgData := model.GetEncodeMessage(tmpData.ActivityData)
			if errBase == nil {
				service.GetRedis().HSet(tmpKeyStr, "base", msgData)
			}
		}
		//任务变更数据
		for k := 0; k < len(tmpData.ChangeTaskList); k++ {
			taskIdStr := strconv.Itoa(int(tmpData.ChangeTaskList[k].TaskId))
			errTask, msgData := model.GetEncodeMessage(tmpData.ChangeTaskList[k])
			if errTask == nil {
				service.GetRedis().HSet(tmpKeyStr, taskIdStr, msgData)
			}
		}
		//删除任务数据
		for k := 0; k < len(tmpData.DelTaskList); k++ {
			taskIdStr := strconv.Itoa(int(tmpData.DelTaskList[k]))
			service.GetRedis().HDel(tmpKeyStr, taskIdStr)
		}
	}
}

func SetRoleActivitySmashEggsMsgToRedis(msg *serverproto.SSActivitySmashEggsMsgSaveNtf) {
	err := model.SetMessageToRedis(RoleActivitySmashEggsPrefix, "", msg)
	if err != nil {
		util.InfoF("SSActivityDataSaveReqSign save err=%v", err)
	}
}