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

package model

import (
	"encoding/base64"
	"errors"
	"fmt"
	"github.com/go-redis/redis"
	"os"
	"rocommon"
	"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"
	"time"
)

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
	//}

	// 新增: 支持同一个redis实例按db列表执行，参数格式: -dbs 0,1,2
	tmpDbStr := ""
	if service.DBListParam != nil {
		tmpDbStr = strings.TrimSpace(*service.DBListParam)
	}

	if tmpDbStr != "" {
		if tmpIpStr == "" {
			util.InfoF("convert abort: ip is empty when using -dbs")
			return
		}
		dbStrList := strings.Split(tmpDbStr, ",")
		dbList := make([]int, 0, len(dbStrList))
		for _, dbRaw := range dbStrList {
			dbStr := strings.TrimSpace(dbRaw)
			dbIdx, err := strconv.Atoi(dbStr)
			if err != nil || dbIdx < 0 {
				util.InfoF("skip invalid db index=%v err=%v", dbStr, err)
				continue
			}
			dbList = append(dbList, dbIdx)
		}
		if len(dbList) == 0 {
			util.InfoF("convert abort: no valid db in -dbs=%v", tmpDbStr)
			return
		}

		// 1) 逐个DB执行原有清洗逻辑
		for idx := 0; idx < len(dbList); idx++ {
			dbIdx := dbList[idx]
			convertOldRedis(tmpIpStr, dbIdx, idx == len(dbList)-1, false)
			util.InfoF("convert finish ip=%v db=%v", tmpIpStr, dbIdx)
		}

		// 2) 按dbs顺序，把后续DB合并到第一个DB
		targetDB := dbList[0]
		for idx := 1; idx < len(dbList); idx++ {
			sourceDB := dbList[idx]
			err = mergeDbIntoFirst(tmpIpStr, sourceDB, targetDB)
			if err != nil {
				util.ErrorF("merge db err source=%v target=%v err=%v", sourceDB, targetDB, err)
				return
			}
			util.InfoF("merge finish source=%v target=%v", sourceDB, targetDB)
		}

		// 3) 仅目标库执行一次持久化
		//convertOldRedis(tmpIpStr, targetDB, true, true)
		util.InfoF("persist finish target db=%v", targetDB)
		return
	}

	//tmpPortStrList := strings.Split(tmpPortStr, ",")
	//for idx := 0; idx < len(tmpPortStrList); idx++ {
	//	ipStr := tmpIpStr + ":" + tmpPortStrList[idx]
	//	if idx == len(tmpPortStrList)-1 {
	//		convertOldRedis(ipStr, 0, true)
	//	} else {
	//		convertOldRedis(ipStr, 0, 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, dbIndex int, lastOne bool, persistOnly bool) {
	//直接获取远端redis数据，调用db接口
	cli := service.NewNetRedisConnector([]string{redisIpStr}, "", dbIndex, 0)
	service.SetRedis(cli)
	util.InfoF("convert start redis=%v db=%v lastOne=%v", redisIpStr, dbIndex, lastOne)
	if persistOnly {
		service.GetRedis().ConfigSet("appendonly", "yes")
		service.GetRedis().BgSave()
		service.GetRedis().BgRewriteAOF()
		return
	}

	//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
}

func GetUidListFromRedis2() {
	cli := service.NewNetRedisConnector([]string{"127.0.0.1:6379"}, "", 7, 0)
	service.SetRedis(cli)
	var uidList []uint64
	tmpUidList, err := service.GetRedis().Keys("account_*").Result()
	if err != nil {
		fmt.Println("getUidListFromRedis2 err=", err)
		return
	}
	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)
	}
	for _, v := range uidList {
		convertActivityOld2Redis(v)
	}
	fmt.Println("getUidListFromRedis2 done")
}

// 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)
	}
}

func convertActivityOld2Redis(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
	}
	data := make([]*serverproto.ActivitiesDetailData, 0)
	for _, v := range tmpRoleActivity.ActivityDataList {
		if v.ActivitiesId == 36 || v.ActivitiesId == 43 || v.ActivitiesId == 49 {
			continue
		}
		data = append(data, v)
	}

	//2.已经开启的列表中清除根据开服时间的id
	retList := service.GetRedis().SMembers(model2.RoleActivityDataOpenListPrefix + uidStr).Val()
	for idx := 0; idx < len(retList); idx++ {
		openActivityId, _ := strconv.Atoi(retList[idx])
		if openActivityId == 36 || openActivityId == 43 || openActivityId == 49 {
			service.GetRedis().SRem(model2.RoleActivityDataOpenListPrefix+uidStr, retList[idx])
			tmpKeyStr := model2.RoleActivityDataPrefix + uidStr + ":" + retList[idx]
			service.GetRedis().Del(tmpKeyStr)
			continue
		}
	}

	var tmpExpiredActivityList []int32
	for idx := 0; idx < len(tmpRoleActivity.ExpiredActivityList); idx++ {
		expiredActivityId := tmpRoleActivity.ExpiredActivityList[idx]
		if expiredActivityId == 36 || expiredActivityId == 43 || expiredActivityId == 49 {
			activityIdStr := strconv.Itoa(int(expiredActivityId))
			tmpKeyStr := model2.RoleActivityDataPrefix + uidStr + ":" + activityIdStr
			service.GetRedis().Del(tmpKeyStr)
			continue
		}
		tmpExpiredActivityList = append(tmpExpiredActivityList, expiredActivityId)
	}

	//重新保存
	tmpRoleActivity.ActivityDataList = data
	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)
	tmpList1, _ := service.GetRedis().Keys(model.RushPetRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpList1); idx++ {
		service.GetRedis().Del(tmpList1[idx])
	}
	service.GetRedis().Del(model.RushPetDataPrefix)
	tmpList2, _ := service.GetRedis().Keys(model.RushPetDataPrefix + "*").Result()
	for idx := 0; idx < len(tmpList2); idx++ {
		service.GetRedis().Del(tmpList2[idx])
	}

	//技能盛典
	service.GetRedis().Del(model.RushSkillScorePrefix)
	service.GetRedis().Del(model.RushSkillPrefix)
	service.GetRedis().Del(model.RushSkillRankPrefix)
	tmpList3, _ := service.GetRedis().Keys(model.RushSkillRankPrefix + "*").Result()
	for idx := 0; idx < len(tmpList3); idx++ {
		service.GetRedis().Del(tmpList3[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)
}

func mergeDbIntoFirst(redisIpStr string, sourceDB int, targetDB int) error {
	if sourceDB == targetDB {
		return nil
	}

	src := service.NewNetRedisConnector([]string{redisIpStr}, "", sourceDB, 0).RedisCli()
	dst := service.NewNetRedisConnector([]string{redisIpStr}, "", targetDB, 0).RedisCli()
	if src == nil || dst == nil {
		return fmt.Errorf("init redis connector failed sourceDB=%v targetDB=%v", sourceDB, targetDB)
	}

	keys, err := src.Keys("*").Result()
	if err != nil {
		return err
	}

	keyStr := "guild:recommendindex"
	for idx := 0; idx < len(keys); idx++ {
		key := keys[idx]
		//特殊公会列表数据处理
		if key == keyStr {
			//源区服工会列表
			ret, err := src.Get(keyStr).Result()
			if err != nil {
				if errors.Is(err, redis.Nil) {
					util.InfoF("key(%v) not exist in SrcDB, will copy directly", keyStr)
					continue
				}
				util.InfoF("LoadRecommendGuild get guildId key=%v err=%v\n", keyStr, err)
				return err
			}
			if ret == "" {
				util.InfoF("key(%v)->val empty", keyStr)
				return err
			}

			str, err := base64.StdEncoding.DecodeString(ret)
			if err != nil {
				util.InfoF("key(%v)->val DecodeString error", keyStr)
				return err
			}
			recommend := &serverproto.RecommendSet{}
			_ = rocommon.GetCodec().Unmarshal(str, recommend)
			//目标区服工会列表
			ret2, err := dst.Get(keyStr).Result()
			if err != nil {
				util.InfoF("LoadRecommendGuild get guildId key=%v err=%v\n", keyStr, err)
				return err
			}
			if ret2 == "" {
				util.InfoF("key(%v)->val empty", keyStr)
				return err
			}

			str2, err := base64.StdEncoding.DecodeString(ret2)
			if err != nil {
				util.InfoF("key(%v)->val DecodeString error", keyStr)
				return err
			}
			recommend2 := &serverproto.RecommendSet{}
			_ = rocommon.GetCodec().Unmarshal(str2, recommend2)
			recommend2.Guild = append(recommend2.Guild, recommend.Guild...)
			_, ss := model.GetEncodeMessage(recommend2)
			if e := dst.Set(keyStr, ss, 0).Err(); e != nil {
				util.ErrorF("key(%v)->val set error =%v", keyStr, e)
				return e
			}
			continue
		}

		srcType, err := src.Type(key).Result()
		if err != nil {
			util.ErrorF("type err sourceDB=%v key=%v err=%v", sourceDB, key, err)
			continue
		}

		srcTTL := int64(-1)
		if ttlDur, e := src.PTTL(key).Result(); e == nil {
			srcTTL = int64(ttlDur / time.Millisecond)
		}

		dstType, err := dst.Type(key).Result()
		if err != nil {
			util.ErrorF("dst type err targetDB=%v key=%v err=%v", targetDB, key, err)
			continue
		}

		if dstType == "none" || dstType == srcType {
			switch srcType {
			case "hash":
				srcMap, e := src.HGetAll(key).Result()
				if e != nil {
					util.ErrorF("hgetall err sourceDB=%v key=%v err=%v", sourceDB, key, e)
					continue
				}
				for field, val := range srcMap {
					if e = dst.HSet(key, field, val).Err(); e != nil {
						util.ErrorF("hset merge err targetDB=%v key=%v field=%v err=%v", targetDB, key, field, e)
					}
				}
			case "set":
				members, e := src.SMembers(key).Result()
				if e != nil {
					util.ErrorF("smembers err sourceDB=%v key=%v err=%v", sourceDB, key, e)
					continue
				}
				if len(members) > 0 {
					args := make([]interface{}, 0, len(members)+1)
					//args = append(args, key)
					for _, m := range members {
						args = append(args, m)
					}
					if e = dst.SAdd(key, args...).Err(); e != nil {
						util.ErrorF("sadd merge err targetDB=%v key=%v err=%v", targetDB, key, e)
					}
				}
			case "zset":
				zitems, e := src.ZRangeWithScores(key, 0, -1).Result()
				if e != nil {
					util.ErrorF("zrange withscores err sourceDB=%v key=%v err=%v", sourceDB, key, e)
					continue
				}
				for _, z := range zitems {
					if e = dst.ZAdd(key, z).Err(); e != nil {
						util.ErrorF("zadd merge err targetDB=%v key=%v member=%v err=%v", targetDB, key, z.Member, e)
					}
				}
			case "list":
				items, e := src.LRange(key, 0, -1).Result()
				if e != nil {
					util.ErrorF("lrange err sourceDB=%v key=%v err=%v", sourceDB, key, e)
					continue
				}
				if len(items) > 0 {
					args := make([]interface{}, 0, len(items)+1)
					//args = append(args, key)
					for _, it := range items {
						args = append(args, it)
					}
					if e = dst.RPush(key, args...).Err(); e != nil {
						util.ErrorF("rpush merge err targetDB=%v key=%v err=%v", targetDB, key, e)
					}
				}
			default:
				if srcType == "string" {
					val, e := src.Get(key).Result()
					if e != nil {
						util.ErrorF("get err sourceDB=%v key=%v err=%v", sourceDB, key, e)
						continue
					}
					if e = dst.Set(key, val, 0).Err(); e != nil {
						util.ErrorF("set err targetDB=%v key=%v err=%v", targetDB, key, e)
					}
				} else {
					util.ErrorF("set err targetDB=%v key=%v type unkowne", targetDB, key)
				}
			}

			if srcTTL > 0 {
				_ = dst.PExpire(key, time.Duration(srcTTL)*time.Millisecond).Err()
			}
		} else {
			dumpData := src.Dump(key).String()
			//if e != nil {
			//	util.ErrorF("dump mismatch err sourceDB=%v key=%v err=%v", sourceDB, key, e)
			//	continue
			//}
			dstKey := fmt.Sprintf("%s__m%d", key, sourceDB)
			restoreTTL := time.Duration(0)
			if srcTTL > 0 {
				restoreTTL = time.Duration(srcTTL) * time.Millisecond
			}
			if e := dst.RestoreReplace(dstKey, restoreTTL, dumpData).Err(); e != nil {
				util.ErrorF("restore mismatch err sourceDB=%v targetDB=%v key=%v dst=%v err=%v", sourceDB, targetDB, key, dstKey, e)
			}
		}
	}
	return nil
}

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

新增同实例多DB模式（方案B）:
	test.exe -ip 127.0.0.1:6379 -dbs 0,1,2
	1.-ip 传完整redis地址(含端口)
	2.-dbs 传要处理的db索引列表，逗号分隔

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到外网然后根据外网的配置启动即可
*/