RoServer/RO_Server_Trunk-branch_0.1.39/roserver/test/model/combine_service.go

package model

import (
	"os"
	"rocommon/service"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/baseserver/set"
	model3 "roserver/battleboss/model"
	model5 "roserver/cross_rank/model"
	model6 "roserver/cross_server/model"
	model2 "roserver/db/model"
	model4 "roserver/game/model"
	model7 "roserver/guild/model"
	"roserver/serverproto"
	"strconv"
	"strings"
)

var typeServerActsList = set.New(set.NonThreadSafe)

func ConvertOldRedis() {
	err := util.InitLog(1, 0, "./log", "test", "")
	if err != nil {
		return
	}
	err = service.ServerCmd.Parse(os.Args[1:])
	if err != nil {
		util.InfoF("param parse err=%v", err)
		return
	}

	//加载活动配置表，查看哪些活动类型是开服时间活动
	path := "./config/csv/"

	serverproto.ItemCfgLoad(path)
	serverproto.ActivitiesCfgLoad(path)
	serverproto.GlobalCfgLoad(path)
	serverproto.RuneShopGiftsCfgLoad(path)
	serverproto.GuildBossCfgLoad(path)
	model.ConvertOldRedisGlobalCfg()
	model.ConvertOldRedisRuneCfg()
	for _, cfgData := range serverproto.ActivitiesCfgLoader {
		startDataList := strings.Split(cfgData.StartTime, ";")
		endDataList := strings.Split(cfgData.EndTime, ";")
		if len(startDataList) > 0 && len(endDataList) > 0 {
			tmpTimeType, _ := model.Str2Num(startDataList[0])
			if tmpTimeType == model.ActivitiesTime_Type_Server {
				typeServerActsList.Add(cfgData.Id)
			}
		}
	}
	typeServerActsList.Add(int32(4)) //每日累充必须重置
	util.InfoF("typeServerActsList=%v", typeServerActsList.List())

	//合并redis进程监听地址
	tmpIpStr := ""
	if *service.IPParam != "" {
		tmpIpStr = *service.IPParam
	}
	tmpPortStr := ""
	if *service.TempParam != "" {
		tmpPortStr = *service.TempParam
	}
	tmpPortStrList := strings.Split(tmpPortStr, ",")
	for idx := 0; idx < len(tmpPortStrList); idx++ {
		ipStr := tmpIpStr + ":" + tmpPortStrList[idx]
		if idx == len(tmpPortStrList)-1 {
			convertOldRedis(ipStr, true)
		} else {
			convertOldRedis(ipStr, false)
		}
		util.InfoF("convert finish ipStr=%v", ipStr)
	}
	//var ipStrList = []string{
	//	"127.0.0.1:6379",
	//}
	//for idx := 0; idx < len(ipStrList); idx++ {
	//	convertOldRedis(ipStrList[idx])
	//}
}

func convertOldRedis(redisIpStr string, lastOne bool) {
	//直接获取远端redis数据，调用db接口
	//redisIpStr = "127.0.0.1:6379"
	cli := service.NewNetRedisConnector([]string{redisIpStr}, "", 0, 0)
	service.SetRedis(cli)

	//0.获取角色uid列表
	uidList := getUidListFromRedis()
	util.InfoF("uidListSize=%v", len(uidList))

	////1.清除当前数据库中不需要的数据(数据清除分个人数据/共用数据)
	for idx := 0; idx < len(uidList); idx++ {
		uid := uidList[idx]
		//1.1活动数据处理 role_activity.go
		convertActivityOldRedis(typeServerActsList, uid)

		//1.2英灵殿 role_arena.go
		convertArenaOldRedis(uid)

		//1.3地图 role_battle.go
		convertRoleBattleOldRedis(uid)

		//1.4赛季 role_competition.go
		convertRoleCompetitionOldRedis(uid)

		//1.5百人道场 role_daochang100.go
		convertRoleDaochang100OldRedis(uid)

		//1.6公会 role_guild.go
		convertRoleGuildOldRedis(uid)

		//1.7邮件 role_mail.go
		convertRoleMailOldRedis(uid)

		//1.8世界boss role_map.go
		convertRoleMapOldRedis(uid)

		//1.9卢恩商店 role_rune.go
		convertRoleRuneOldRedis(uid)

		//1.10冲榜 role_rush.go
		convertRoleRushOldRedis(uid)

		//1.11爬塔 role_tower.go
		convertRoleTowerOldRedis(uid)

		//1.12背包数据删除(背包内的活动数据)
		convertRoleBagOldRedis(uid)
	}

	//系统共用数据部分
	//1.1.1 role_activity.go
	service.GetRedis().Del(model.ActivitiesCollectionDataPrefix) //活动全局数据
	//1.2.1 role_arena.go
	convertArenaOldCommonRedis()
	//1.3.1 role_battle.go 远征之门积分排行榜
	service.GetRedis().Del(model.ExpeditionScoreRankPrefix) //合并数据后数据自动重排
	//1.3.2 推图冲榜（冒险盛典）排行榜
	service.GetRedis().Del(model.RushMapScorePrefix)
	service.GetRedis().Del(model.RushMapPrefix)
	service.GetRedis().Del(model.RushMapRankPrefix)
	tmpList, _ := service.GetRedis().Keys(model.RushMapRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
	//1.4.1 role_competition.go
	convertRoleCompetitionOldCommonRedis()
	//1.5.1 role_daochang100.go
	convertRoleDaochang100OldCommonRedis()
	//1.6.1 role_guild.go
	convertRoleGuildOldCommonRedis()
	//1.7.1 role_mail.go
	convertRoleMailOldCommonRedis()
	//1.8.1 role_map.go
	convertRoleMapOldCommonRedis()
	//1.10.1 role_rush.go
	//宠物盛典 ,技能盛典
	convertRoleRushOldCommonRedis()
	//1.11.1 role_tower.go
	convertRoleTowerOldCommonRedis()
	//1.12.1跨服玩法 巅峰爬塔/远航试炼
	convertRoleCrossOldRedisCommon()
	//战斗记录数据清除
	service.GetRedis().Del(model.BattleRecordMapPrefix)
	service.GetRedis().Del(model.BattleRecordDetailPrefix)
	service.GetRedis().Del(model.BattleRecordDetailCheckPrefix)
	//卡片收集rank清除
	service.GetRedis().Del(model.CardCollectRankPrefix)
	//信物收集
	service.GetRedis().Del(model.KeepSakeCollectRankPrefix)
	//推图排行榜和历史最大战力排行榜(aof启动后会自动合并zset中的排行榜数据)

	////2.导入数据到新redis数据库中
	//开启aof
	service.GetRedis().ConfigSet("appendonly", "yes")
	//service.GetRedis().ConfigSet("aof-use-rdb-preamble", "no")
	service.GetRedis().BgSave()
	service.GetRedis().BgRewriteAOF()
}

func getUidListFromRedis() []uint64 {
	var uidList []uint64
	tmpUidList, err := service.GetRedis().Keys("account_*").Result()
	if err != nil {
		return uidList
	}
	for idx := 0; idx < len(tmpUidList); idx++ {
		tmpMsg := &serverproto.SSAccountGetRoleListAck{}
		err := model.GetMessageFromRedis(tmpUidList[idx], "", tmpMsg)
		if err != nil || len(tmpMsg.Roles) <= 0 {
			util.ErrorF("account=%v getUidListFromRedis err=%v", tmpUidList[idx], err)
			continue
		}
		uidList = append(uidList, tmpMsg.Roles[0].Uid)
	}
	return uidList
}

// role_activity.go
func convertActivityOldRedis(typeServerActsList set.Interface, uid uint64) {
	uidStr := strconv.FormatUint(uid, 10)
	tmpRoleActivity := &serverproto.RoleActivity{}
	err := model2.GetSystemDataFromRedis(model2.RoleActivityDataSignPrefix, uid, tmpRoleActivity)
	if err != nil && err != service.NIL {
		util.ErrorF("uid=%v [convertActivityOldRedis] Get RoleActivitySign err=%v", uid, err)
		return
	}

	//1.过期列表中保留着以往开过的所有过期活动 ->清除根据开服时间的活动id
	var tmpExpiredActivityList []int32
	for idx := 0; idx < len(tmpRoleActivity.ExpiredActivityList); idx++ {
		expiredActivityId := tmpRoleActivity.ExpiredActivityList[idx]
		if !typeServerActsList.Has(expiredActivityId) {
			tmpExpiredActivityList = append(tmpExpiredActivityList, expiredActivityId)
			continue
		}

		activityIdStr := strconv.Itoa(int(expiredActivityId))
		tmpKeyStr := model2.RoleActivityDataPrefix + uidStr + ":" + activityIdStr
		service.GetRedis().Del(tmpKeyStr)
	}
	//2.已经开启的列表中清除根据开服时间的id
	retList := service.GetRedis().SMembers(model2.RoleActivityDataOpenListPrefix + uidStr).Val()
	for idx := 0; idx < len(retList); idx++ {
		openActivityId, _ := strconv.Atoi(retList[idx])
		if openActivityId <= 0 {
			service.GetRedis().SRem(model2.RoleActivityDataOpenListPrefix+uidStr, retList[idx])
			continue
		}
		if typeServerActsList.Has(int32(openActivityId)) {
			service.GetRedis().SRem(model2.RoleActivityDataOpenListPrefix+uidStr, retList[idx])
			tmpKeyStr := model2.RoleActivityDataPrefix + uidStr + ":" + retList[idx]
			service.GetRedis().Del(tmpKeyStr)
		}
	}
	//3.签到数据重置
	tmpRoleActivity.SignInfo = &serverproto.SignUp{
		SignRound: 1,
		CurDay:    0,
		CurSignInfo: &serverproto.CurRoundSign{
			LastSign: 0,
		},
	}
	//重新保存
	tmpRoleActivity.ExpiredActivityList = tmpExpiredActivityList
	err = model2.SetSystemDataToRedis(model2.RoleActivityDataSignPrefix, uid, tmpRoleActivity)
	if err != nil {
		util.ErrorF("uid=%v [convertActivityOldRedis] save err=%v", uid, err)
	}
}

// roleanera
func convertArenaOldRedis(uid uint64) {
	//uidStr := strconv.FormatUint(uid, 10)
	//1.竞技场赛季个人数据重置
	tmpRoleArena := &serverproto.RoleArena{}
	err := model2.GetSystemDataFromRedis(model2.RoleArenaDataPrefix, uid, tmpRoleArena)
	if err != nil && err != service.NIL {
		util.ErrorF("uid=%v [convertArenaOldRedis] Get RoleArena err=%v", uid, err)
		return
	}
	if tmpRoleArena.Arena == nil {
		return
	}
	//重置剩余挑战次数/剩余购买次数
	tmpRoleArena.Arena.ChallengeCount = model.GlobalDaoChangChallengeCount
	tmpRoleArena.Arena.BuyCount = model.GlobalDaoChangByCount
	//重置段位/积分
	tmpRoleArena.Arena.ArenaSeasonId = 0
	tmpRoleArena.Arena.LastArenaSeasonTime = 0
	tmpRoleArena.Arena.RecordWinCount = 0
	tmpRoleArena.Arena.RecordTotalCount = 0
	tmpRoleArena.Arena.ArenaSeasonIdReduce = 0
	tmpRoleArena.Arena.Score = 0
	tmpRoleArena.Arena.OldScore = 0
	tmpRoleArena.Arena.RushArena = nil
	err = model2.SetSystemDataToRedis(model2.RoleArenaDataPrefix, uid, tmpRoleArena)
	if err != nil {
		util.ErrorF("uid=%v [convertArenaOldRedis] Set RoleArena err=%v", uid, err)
	}
}
func convertArenaOldCommonRedis() {
	//2.匹配数据处理
	//英灵殿积分排行榜，只用来match使用
	service.GetRedis().Del(model.ArenaRankMatchPrefix)

	//3.积分排行榜清除
	service.GetRedis().Del(model.ArenaRankPrefix)
	service.GetRedis().Del(model.ArenaPreRankPrefix)
	service.GetRedis().Del(model.ArenaTopRankPrefix)
	tmpTopList, _ := service.GetRedis().Keys(model.ArenaTopRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpTopList); idx++ {
		if tmpTopList[idx] != model.ArenaTopRankPrefix {
			service.GetRedis().Del(tmpTopList[idx])
		}
	}

	//4.冲榜相关处理
	service.GetRedis().Del(model.RushArenaRankPrefix) //冲榜相关
	tmpTopList, _ = service.GetRedis().Keys(model.RushArenaRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpTopList); idx++ {
		service.GetRedis().Del(tmpTopList[idx])
	}
	service.GetRedis().Del(model.RushArenaPrefix) //最终排行
}

// rolebattle
func convertRoleBattleOldRedis(uid uint64) {
	//uidStr := strconv.FormatUint(uid, 10)
	tmpRoleBattle := &serverproto.RoleBattle{}
	err := model2.GetSystemDataFromRedis(model2.RoleBattleDataPrefix, uid, tmpRoleBattle)
	if err != nil && err != service.NIL {
		util.ErrorF("uid=%v [convertRoleBattleOldRedis] Get RoleBattle err=%v", uid, err)
		return
	}
	//1.时光之力
	if tmpRoleBattle.QuickBattle != nil {
		tmpRoleBattle.QuickBattle.DayTimes = 0
	}

	//2.远征之门积分排行榜 共用数据部分
	//service.GetRedis().Del(model.ExpeditionScoreRankPrefix)

	//3.推图冲榜（冒险盛典）
	tmpRoleBattle.RushMap = &serverproto.RushMap{}

	err = model2.SetSystemDataToRedis(model2.RoleBattleDataPrefix, uid, tmpRoleBattle)
	if err != nil {
		util.ErrorF("uid=%v [convertRoleBattleOldRedis] save err=%v", uid, err)
	}
}

// rolecompetition
func convertRoleCompetitionOldRedis(uid uint64) {
	uidStr := strconv.FormatUint(uid, 10)
	service.GetRedis().Del(model2.RoleCompetitionDataPrefix + uidStr)

	//1.招募季，地图排行榜（需要清空地图排行榜）

	//夺宝数据清空(在道场数据中)

}
func convertRoleCompetitionOldCommonRedis() {
	//历史进行到的赛季数据伤处
	service.GetRedis().Del(model.ServerCompetitionPrefix)

	//1.招募季赛季信息删除
	service.GetRedis().Del(model.CompetitionMapRankPrefix)
	tmpList, _ := service.GetRedis().Keys(model.CompetitionMapRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
	//2.选拔季
	service.GetRedis().Del(model.CompetitionScoreRankPrefix)
	tmpList, _ = service.GetRedis().Keys(model.CompetitionScoreRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
	//3.夺宝赛季:道场轮盘/活动转盘
	service.GetRedis().Del(model.CompetitionDuoBaoScoreRankPrefix)
	tmpList, _ = service.GetRedis().Keys(model.CompetitionDuoBaoScoreRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
	//大奖日志数据
	service.GetRedis().Del(model.RoleDaoChang100WheeLogPrefix)

	//4.占星数据
	service.GetRedis().Del(model.CompetitionZhanBuScoreRankPrefix)
	tmpList, _ = service.GetRedis().Keys(model.CompetitionZhanBuScoreRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
	//4.偶像季数据
	service.GetRedis().Del(model.CompetitionIdolScoreRankPrefix)
	tmpList, _ = service.GetRedis().Keys(model.CompetitionIdolScoreRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
}

// roleguild
func convertRoleGuildOldRedis(uid uint64) {
	//serverproto.SSGuildBossRefreshNtf
	//公会个人数据清楚
	tmpRoleGuild := &serverproto.RoleGuild{}
	err := model2.GetSystemDataFromRedis(model2.RoleGuildDataPrefix, uid, tmpRoleGuild)
	if err != nil && err != service.NIL {
		util.InfoF("uid=%v [convertRolegGuildOldRedis] err%v", uid, err)
		return
	}
	tmpRoleGuild.BossFight = tmpRoleGuild.BossFight[:0]
	tmpRoleGuild.GuildBattle = nil
	tmpRoleGuild.DemonInfo = nil
	tmpRoleGuild.EliteBossCd = 0
	err = model2.SetSystemDataToRedis(model2.RoleGuildDataPrefix, uid, tmpRoleGuild)
	if err != nil {
		util.ErrorF("uid=%v [convertRolegGuildOldRedis] err=%v", uid, err)
	}
}
func convertRoleGuildOldCommonRedis() {
	//1.公会狩猎-公会boss数据
	service.GetRedis().Del(model.GuildBossPrefix)
	tmpList, _ := service.GetRedis().Keys(model.GuildBossPrefix + "*").Result()
	//重新初始化公会狩猎boss
	for idx := 0; idx < len(tmpList); idx++ {
		for _, data := range serverproto.GuildBossCfgLoader {
			bossInfo := &serverproto.GuildBossInfo{}
			if data.BossType == model7.Guild_Boss_Type_Normal {
				nowTime := util.GetCurrentTimeNow()
				if nowTime.Hour() == 4 {
					bossInfo.BossState = model7.Guild_Boss_State_Wait_Summon
				} else {
					bossInfo.BossState = model7.Guild_Boss_State_Fight
				}
				bossInfo.RefreshTime = uint64(util.GetCurrentTime())
				bossInfo.MaxDam = &serverproto.GuildFight{}
			} else if data.BossType == model7.Guild_Boss_Type_Elite {
				bossInfo.BossState = model7.Guild_Boss_State_Wait_Summon
			}

			fieldStr := strconv.FormatUint(uint64(data.Id), 10)
			err, msgStr := model.GetEncodeMessage(bossInfo)
			if err == nil {
				ret, err := service.GetRedis().HSet(tmpList[idx], fieldStr, msgStr).Result()
				if err != nil {
					util.InfoF("[SaveGuildBoss] err:%v %v", err, ret)
					return
				}
			}
		}
		//service.GetRedis().Del(tmpList[idx])
	}

	//2.公会魔王
	service.GetRedis().Del(model.GuildDemonPrefix)
	service.GetRedis().Del(model.GuildDemonRewardPrefix)
	tmpList, _ = service.GetRedis().Keys(model.GuildDemonRewardPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
	service.GetRedis().Del(model.GuildDemonGuildPrefix)
	service.GetRedis().Del(model.GuildDemonMVPPrefix)

	//3.公会战排行榜(百人道场积分排行榜)
	//已经在百人道场中清除RoleDaoChang100GuildRankPrefix

	//4.公会战
	service.GetRedis().Del(model7.GuildBattlePrefix)
	tmpList, _ = service.GetRedis().Keys(model7.GuildBattlePrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
	//公会战合服
	service.GetRedis().Del(model7.GuildBattleRankPrefix)
	tmpList, _ = service.GetRedis().Keys(model7.GuildBattleRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
	service.GetRedis().Del(model7.GuildBattleLogPrefix)
	tmpList, _ = service.GetRedis().Keys(model7.GuildBattleLogPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
	service.GetRedis().Del(model7.GuildBattleBasePrefix)
	service.GetRedis().Del(model7.GuildBattleTablePrefix)
}

// roledaochang100
func convertRoleDaochang100OldRedis(uid uint64) {
	uidStr := strconv.FormatUint(uid, 10)
	//1.log状态重置
	service.GetRedis().HSet(model.RoleDaoChang100Prefix+uidStr, "log", 0)

	tmpRoleDaochang100 := &serverproto.RoleDaoChang100{}
	if !model2.GetRoleDaoChang100FromRedis(uid, tmpRoleDaochang100) {
		//util.ErrorF("uid=%v [convertRoleDaochang100OldRedis] load", uid)
		return
	}
	//2.重置挑战次数
	tmpRoleDaochang100.LogState = false
	tmpRoleDaochang100.ChallengeCount = model.GlobalDaoChang100ChallengeCount
	//4.道场转盘数据清空(赛季相关)
	tmpRoleDaochang100.WheelRewardItemList = nil
	tmpRoleDaochang100.WheelOpen = false
	tmpRoleDaochang100.WheelRefreshNum = 0
	tmpRoleDaochang100.TemplateIdx = 0
	tmpRoleDaochang100.WheelNum = 0
	tmpRoleDaochang100.WheelIdx = 0
	model2.SetRoleDaoChang100ToRedis(uid, tmpRoleDaochang100)

	//3.占位奖励列表清空
	service.GetRedis().Del(model.DaoChang100RewardPrefix + uidStr)

}
func convertRoleDaochang100OldCommonRedis() {
	//4.占位数据初始化为机器人数据
	service.GetRedis().Del(model.DaoChang100Prefix)

	//5.百人道场公会贡献点排行榜
	//占位获取奖励中包含积分
	service.GetRedis().Del(model.RoleDaoChang100GuildRankPrefix)
	tmpList, _ := service.GetRedis().Keys(model.RoleDaoChang100GuildRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
}

// rolemail
func convertRoleMailOldRedis(uid uint64) {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := model2.RoleMailDataPrefix + uidStr

	//1.个人身上的全局邮件ID重置
	service.GetRedis().HDel(keyStr, "gMaxId")
}

func convertRoleMailOldCommonRedis() {
	//1.删除全局邮件
	service.GetRedis().Del(model2.RoleGlobalMailListPrefix) //列表
	service.GetRedis().Del(model2.RoleGlobalMailPrefix)
	tmpList, _ := service.GetRedis().Keys(model2.RoleGlobalMailPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
}

// rolemap
func convertRoleMapOldRedis(uid uint64) {
	//uidStr := strconv.FormatUint(uid, 10)
	tmpRoleMap := &serverproto.RoleMap{}
	err := model2.GetSystemDataFromRedis(model2.RoleMapDataPrefix, uid, tmpRoleMap)
	if err != nil && err != service.NIL {
		util.InfoF("uid=%v [convertRoleMapOldRedis] RoleMap err=%v", uid, err)
		return
	}
	tmpRoleMap.WorldBossCount = 0
	tmpRoleMap.WorldBossChallengeList = []int32{}

	err = model2.SetSystemDataToRedis(model2.RoleMapDataPrefix, uid, tmpRoleMap)
	if err != nil {
		util.ErrorF("uid=%v [convertRoleMapOldRedis] save err=%v", uid, err)
	}
}
func convertRoleMapOldCommonRedis() {
	//重置世界boss数据
	//1.世界boss列表数据
	service.GetRedis().Del(model3.WorldBossStatePrefix)
	//2.挑战过世界boss的玩家列表
	tmpList, _ := service.GetRedis().Keys(model3.WorldBossStateUidListPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
}

// rolerune
func convertRoleRuneOldRedis(uid uint64) {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := model2.RoleRuneDataPrefix + uidStr
	valList, err := service.GetRedis().HGetAll(keyStr).Result()
	if err != nil {
		util.InfoF("uid=%v [convertRoleRuneOldRedis] err=%v", uid, err)
		return
	}
	//1.重置日礼包/周礼包/月礼包 购买限制
	//2.重置飞艇探索数据
	for k, v := range valList {
		if k == "runeBase" {
			//todo
		} else if k == "runeExplore" {
			service.GetRedis().HDel(keyStr, k)
		} else {
			shopData := &serverproto.RuneShop{}
			err = model.GetDecodeMessage(shopData, v)
			if err != nil {
				continue
			}
			//检查是否是日礼包/周礼包/月礼包 商品数据
			if shopData.ShopId == model4.Rune_Shop_Type_Bag {
				service.GetRedis().HDel(keyStr, k)
			}
		}
	}
}

// rolerush
func convertRoleRushOldRedis(uid uint64) {
	//1.技能盛典个人数据清除
	uidStr := strconv.FormatUint(uid, 10)
	service.GetRedis().Del(model2.RoleRushDataPrefix + uidStr)

	//2.宠物盛典个人数据清除
	baseStr, err := service.GetRedis().HGet(model2.RolePetDataPrefix+uidStr, model2.RolePetDataFieldPrefix_base).Result()
	if err != nil {
		if err != service.NIL {
			util.InfoF("uid=%v [convertRoleRushOldRedis] pet err=%v", uid, err)
		}
		return
	}
	tmpRolePet := &serverproto.RolePet{}
	err = model.GetDecodeMessage(tmpRolePet, baseStr)
	if err == nil {
		tmpRolePet.RushPet = nil
		err1, msgData := model.GetEncodeMessage(tmpRolePet)
		if err1 == nil {
			service.GetRedis().HSet(model2.RolePetDataPrefix+uidStr,
				model2.RolePetDataFieldPrefix_base, msgData)
		}
	}

	//3.其他盛典个人数据在对应不同系统中做清除
}
func convertRoleRushOldCommonRedis() {
	//宠物盛典
	service.GetRedis().Del(model.RushPetScorePrefix)
	service.GetRedis().Del(model.RushPetPrefix)
	service.GetRedis().Del(model.RushPetRankPrefix)
	tmpList, _ := service.GetRedis().Keys(model.RushPetRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
	service.GetRedis().Del(model.RushPetDataPrefix)
	tmpList, _ = service.GetRedis().Keys(model.RushPetDataPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}

	//技能盛典
	service.GetRedis().Del(model.RushSkillScorePrefix)
	service.GetRedis().Del(model.RushSkillPrefix)
	service.GetRedis().Del(model.RushSkillRankPrefix)
	tmpList, _ = service.GetRedis().Keys(model.RushSkillRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
}

// rolecross
func convertRoleCrossOldRedisCommon() {
	//1.巅峰之塔
	service.GetRedis().Del(model5.CrossMaxFightPowerRankPrefix)
	service.GetRedis().Del(model5.CrossMaxFightPowerRankOldPrefix)
	service.GetRedis().Del(model5.TopTowerWinRankPrefix)
	service.GetRedis().Del(model5.FightInfoPrefix)
	service.GetRedis().Del(model5.CommonInfoPrefix)

	//2.远航试炼
	service.GetRedis().Del(model6.YuanHangTrialFightInfoPrefix)
	service.GetRedis().Del(model6.YuanHangTrialItemPrefix)
	service.GetRedis().Del(model6.YuanHangTrialRankPrefix)
}

// roletower
func convertRoleTowerOldRedis(uid uint64) {
	//个人冲榜数据清除
	tmpRoleTower := &serverproto.RoleTower{}
	err := model2.GetSystemDataFromRedis(model2.RoleTowerDataPrefix, uid, tmpRoleTower)
	if err != nil && err != service.NIL {
		util.InfoF("uid=%v [convertRoleTowerOldRedis] err=%v", uid, err)
		return
	}
	tmpRoleTower.RushTower = nil

	err = model2.SetSystemDataToRedis(model2.RoleTowerDataPrefix, uid, tmpRoleTower)
	if err != nil {
		util.ErrorF("uid=%v [convertRoleTowerOldRedis] save err=%v", uid, err)
	}
}

// 1.12背包数据删除(背包内的活动数据)
func convertRoleBagOldRedis(uid uint64) {
	tmpRoleBag := &serverproto.RoleBag{}
	err := model2.GetSystemDataFromRedis(model2.RoleBagDataPrefix, uid, tmpRoleBag)
	if err != nil && err != service.NIL {
		util.ErrorF("uid=%v del bag activity itemlist err=%v", uid, err)
		return
	}
	bSave := false
	var newItemList []*serverproto.ItemData
	for idx := 0; idx < len(tmpRoleBag.ItemList); idx++ {
		tmpItem := tmpRoleBag.ItemList[idx]
		cfgData := model4.GetItemCfg(tmpItem.ConfigId)
		if cfgData == nil {
			bSave = true
			continue
		}
		//删除活动类型道具
		if cfgData.ItemTime == model4.Item_Time_Type_Competition_2 ||
			cfgData.ItemTime == model4.Item_Time_Type_Competition_4 ||
			cfgData.ItemTime == model4.Item_Time_Type_Activities ||
			cfgData.ItemTime == model4.Item_Time_Type_Likability {
			bSave = true
			continue
		}
		newItemList = append(newItemList, tmpItem)
	}

	if bSave {
		tmpRoleBag.ItemList = newItemList
		err = model2.SetSystemDataToRedis(model2.RoleBagDataPrefix, uid, tmpRoleBag)
		if err != nil {
			util.ErrorF("uid=%v save bag item list err=%v", uid, err)
		}
	}
}
func convertRoleTowerOldCommonRedis() {
	//试炼盛典-爬塔数据清除
	service.GetRedis().Del(model.RushTowerPrefix)
	service.GetRedis().Del(model.RushTowerRankPrefix)
	tmpList, _ := service.GetRedis().Keys(model.RushTowerRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpList); idx++ {
		service.GetRedis().Del(tmpList[idx])
	}
	//爬塔排行榜清除
	//service.GetRedis().Del(model.TowerLevelRankPrefix) 合并数据后数据自动重排
	service.GetRedis().Del(model.TowerFightpowerRankPrefix)
}

/*
注意：下面操作需要在同一个redis版本中操作，即需要在外网使用的redis版本下进行操作

1.获取外网rdb文件，并重新修改启动该rdb文件的redis*.conf文件
	修改conf文件如下：
		1.在675行添加(表示生成的aof文件中不包行rdb文件，只有aof格式文件内容):aof-use-rdb-preamble no
		2.port修改成当前外网的redis*.conf文件一致
		3.appendfilename修改成appendonly[端口号].aof，appendonly7001.aof
		4.修改appendonly为no(关闭appendonly，为了启动redis时直接读取rdb文件)
2.第1步的修改完成后，按照外网的方式利用获取到的外网rdb启动(需改后的redis*.conf文件和对应的rdb文件)
3.用命令行启动合服处理进程，格式如下:
	test.exe -ip 127.0.0.1 -diff 7001,7002,7003
	1.test.exe为合服处理进程(负责清空redis中需要清空的数据)
	2.-ip为第2步中redis启动时监听的ip地址
	3.-diff为redis启动时坚挺的端口，多个端口中间用逗号隔开，例如:7001,7002,7003
4.合并第3步操作后生成的appendonly[端口号].aof文件，如下:
	cat appendonly7001.aof appendonly7002.aof appendonly7003.aof > new.aof
5.第4步生成的new.aof文件就是合服后的数据，需要转换成rdb文件
	获取1步骤的redis*.conf文件修改如下:
		1.appendonly修改为yes
		2.删除之前添加的aof-use-rdb-preamble no
		3.appendfilename修改成new.aof
		4.启动端口修改成没有使用过的端口，例如6379
6.利用第4不生成的new.aof文件和第5不修改后的redis*.conf文件启动一个新的redis进程，并执行redis命令bgsave(或
   者等待一段时间会自动生成对应的rdb文件)，查看目录下是否生成dump.rdb文件，如果生成说明合服数据库已经成功生成
7.第6不生成的rdb文件即为合服后的数据库，把该rdb文件copy到外网然后根据外网的配置启动即可
*/