log-server/service/task/redis_query_option.go

package task

import (
	"context"
	"encoding/json"
	"fmt"
	"log-server/global"
	"log-server/model/task"
)

//定义游戏厂商结构体，以及返回游戏厂商结构体
func GamePortOptionQuery() (channelOptionReturn []task.GamePortOption){
	var channelOption []task.GamePortOption	//回传前端的信息结构体
	var objectChannel task.GamePortOption	//用于反序列化的结构体
	ctx := context.Background()	//redis上下文环境
	key := "typeManage:gameChannel"	//查询的redis表
	channelKeys, _ := global.GVA_REDIS.HKeys(ctx, key).Result()	//hash表中的所有key
	return RedisQueryChannel(ctx, channelOption, objectChannel, key, channelKeys)
}

//定义登录方式结构体，以及返回登录方式结构体
func LoginTypeOptionQuery() (loginOptionReturn []task.LoginTypeOption){
	var loginOption []task.LoginTypeOption	//回传前端的信息结构体
	var objectLogin task.LoginTypeOption	//用于反序列化的结构体
	ctx := context.Background()	//redis上下文环境
	key := "typeManage:loginType"	//查询的redis表
	loginKeys, _ := global.GVA_REDIS.HKeys(ctx, key).Result()	//hash表中的所有key
	return RedisQueryLogin(ctx, loginOption, objectLogin, key, loginKeys)
}

//定义账号类型结构体，以及返回账号类型结构体
func AccountTypeOptionQuery() (accountOptionReturn []task.AccountTypeOption){
	var accountOption []task.AccountTypeOption	//回传前端的信息结构体
	var objectAccount task.AccountTypeOption	//用于反序列化的结构体
	ctx := context.Background()	//redis上下文环境
	key := "typeManage:accountType"	//查询的redis表
	accountKeys, _ := global.GVA_REDIS.HKeys(ctx, key).Result()	//hash表中的所有key
	return RedisQueryAccount(ctx, accountOption, objectAccount, key, accountKeys)
}

//定义负责人结构体，以及返回负责人结构体
func ResponsiblePersonOptionQuery() (responsiblePersonOptionReturn []task.ResponsiblePersonOption){
	var responsiblePersonOption []task.ResponsiblePersonOption	//回传前端的信息结构体
	var objectResponsiblePerson task.ResponsiblePersonOption	//用于反序列化的结构体
	ctx := context.Background()	//redis上下文环境
	key := "typeManage:responsiblePerson"	//查询的redis表
	responsiblePersonKeys, _ := global.GVA_REDIS.HKeys(ctx, key).Result()	//hash表中的所有key
	return RedisQueryResponsiblePerson(ctx, responsiblePersonOption, objectResponsiblePerson, key, responsiblePersonKeys)
}

//定义游戏列表结构体，以及返回游戏列表结构体
func GameListOptionQuery() (gameListOptionReturn []task.GameListOption){
	var gameListOption []task.GameListOption	//回传前端的信息结构体
	var objectGameList task.GameListOption	//用于反序列化的结构体
	ctx := context.Background()	//redis上下文环境
	key := "typeManage:gameList"	//查询redis表
	gameListKeys, _ := global.GVA_REDIS.HKeys(ctx, key).Result()	//hash表中的所有key
	return RedisQueryGameList(ctx, gameListOption, objectGameList, key, gameListKeys)
}






//查询游戏厂商具体数据
func RedisQueryChannel(ctx context.Context, channelOption []task.GamePortOption, objectChannel task.GamePortOption, keyName string, keys []string) (channelOptionReturn []task.GamePortOption){
	for k := range keys{
		//遍历查找redis记录
		bytes, _ := global.GVA_REDIS.HGet(ctx, keyName, keys[k]).Bytes()
		json.Unmarshal(bytes, &objectChannel)
		fmt.Println(objectChannel)
		//将记录添加到数组
		channelOption =  append(channelOption, objectChannel)
	}
	return channelOption
}

//查询登录方式具体数据
func RedisQueryLogin(ctx context.Context, loginOption []task.LoginTypeOption, objectLogin task.LoginTypeOption, keyName string, keys []string) (loginOptionReturn []task.LoginTypeOption){
	for k := range keys{
		//遍历查找redis记录
		bytes, _ := global.GVA_REDIS.HGet(ctx, keyName, keys[k]).Bytes()
		json.Unmarshal(bytes, &objectLogin)
		fmt.Println(objectLogin)
		//将记录添加到数组
		loginOption =  append(loginOption, objectLogin)
	}
	return loginOption
}

//查询账号类型具体数据
func RedisQueryAccount(ctx context.Context, accountOption []task.AccountTypeOption, objectAccount task.AccountTypeOption, keyName string, keys []string) (accountOptionReturn []task.AccountTypeOption){
	for k := range keys{
		//遍历查找redis记录
		bytes, _ := global.GVA_REDIS.HGet(ctx, keyName, keys[k]).Bytes()
		json.Unmarshal(bytes, &objectAccount)
		fmt.Println(objectAccount)
		//将记录添加到数组
		accountOption =  append(accountOption, objectAccount)
	}
	return accountOption
}

//查询负责人具体数据
func RedisQueryResponsiblePerson(ctx context.Context, responsiblePersonOption []task.ResponsiblePersonOption, objectResponsiblePerson task.ResponsiblePersonOption, keyName string, keys []string) (responsiblePersonOptionReturn []task.ResponsiblePersonOption){
	for k := range keys{
		//遍历查找redis记录
		bytes, _ := global.GVA_REDIS.HGet(ctx, keyName, keys[k]).Bytes()
		json.Unmarshal(bytes, &objectResponsiblePerson)
		fmt.Println(objectResponsiblePerson)
		//将记录添加到数组
		responsiblePersonOption =  append(responsiblePersonOption, objectResponsiblePerson)
	}
	return responsiblePersonOption
}

//查询游戏列表具体数据
func RedisQueryGameList(ctx context.Context, gameListOption []task.GameListOption, objectGameList task.GameListOption, keyName string, keys []string) (gameListOptionReturn []task.GameListOption){
	for k := range keys{
		//遍历查找redis记录
		bytes, _ := global.GVA_REDIS.HGet(ctx, keyName, keys[k]).Bytes()
		json.Unmarshal(bytes, &objectGameList)
		fmt.Println(objectGameList)
		//将记录添加到数组
		gameListOption =  append(gameListOption, objectGameList)
	}
	return gameListOption
}