lc_veterans/util/redis.go

package util

import (
	"fmt"
	"github.com/go-redis/redis"
	device "iot_manager_service/app/device/dao"
	system "iot_manager_service/app/system/dao"
	"iot_manager_service/config"
	"strconv"
	"strings"
	"time"
)

var Redis *redis.Client

func InitRedis() error {
	cfg := config.Instance()
	addr := cfg.Redis.Host
	Redis = redis.NewClient(&redis.Options{
		Addr:         addr,
		DialTimeout:  10 * time.Second,
		ReadTimeout:  30 * time.Second,
		WriteTimeout: 30 * time.Second,
		PoolSize:     10,
		PoolTimeout:  30 * time.Second,
		Password:     cfg.Redis.Password,
	})
	_, err := Redis.Ping().Result()
	if err != nil {
		return err
	}
	return nil
}

const (
	UserKey        = "%s:sys:user:%d"
	ModuleTypeKey  = "%s:dict:module_type:%d"
	ControlTypeKey = "%s:dict:control_type:%d"
	TenantNameKey  = "%s:sys:tenant_name:%s"
	RoleNameKey    = "%s:sys:role_name:%d"
	SexNameKey     = "%s:sys:sex_name:%d"

	ControlType = "control_type"
	ModuleType  = "module_his_type"
	Sex         = "sex"
)

func GetUserName(tenantId string, id int64) string {
	var name string
	key := fmt.Sprintf(UserKey, tenantId, id)
	name, err := Redis.Get(key).Result()
	if err != nil {
		user := &system.User{ID: id}
		if err := user.GetUser(); err != nil {
			fmt.Printf("GetUser err = %s \n", err)
		} else {
			name = user.Name
			Redis.Set(key, name, time.Second*10)
		}
	}
	return name
}

func GetModuleName(tenantId string, id int) string {
	var name string
	key := fmt.Sprintf(ModuleTypeKey, tenantId, id)
	name, err := Redis.Get(key).Result()
	if err != nil {
		dict := &device.Dict{Code: ModuleType, DictKey: strconv.Itoa(id)}
		if err := dict.GetByCodeAndKey(); err != nil {
			fmt.Printf("GetByCodeAndKey err = %d \n", err)
		} else {
			name = dict.DictValue
			Redis.Set(key, name, -1)
		}
	}
	return name
}

func GetControlType(tenantId string, id int) string {
	var name string
	key := fmt.Sprintf(ControlTypeKey, tenantId, id)
	name, err := Redis.Get(key).Result()
	if err != nil {
		dict := &device.Dict{Code: ControlType, DictKey: strconv.Itoa(id)}
		if err := dict.GetByCodeAndKey(); err != nil {
			fmt.Printf("GetByCodeAndKey err = %d \n", err)
		} else {
			name = dict.DictValue
			Redis.Set(key, name, -1)
		}
	}
	return name
}

func GetSexName(tenantId string, id int) string {
	var name string
	key := fmt.Sprintf(SexNameKey, tenantId, id)
	name, err := Redis.Get(key).Result()
	if err != nil {
		dict := &device.Dict{Code: Sex, DictKey: strconv.Itoa(id)}
		if err := dict.GetByCodeAndKey(); err != nil {
			fmt.Printf("GetByCodeAndKey err = %d \n", err)
		} else {
			name = dict.DictValue
			Redis.Set(key, name, -1)
		}
	}
	return name
}

func GetTenantName(tenantId string, id string) string {
	var name string
	key := fmt.Sprintf(TenantNameKey, tenantId, id)
	name, err := Redis.Get(key).Result()
	if err != nil {
		tenant := &system.Tenant{TenantId: id}
		if err := tenant.GetTenant(); err != nil {
			fmt.Printf("GetTenant err = %s \n", err)
		} else {
			name = tenant.TenantName
			Redis.Set(key, name, -1)
		}
	}
	return name
}

func GetRoleNames(tenantId string, roleIds string) string {
	roleIdArr := strings.Split(roleIds, ",")
	names := ""
	for _, roleId := range roleIdArr {
		id, _ := strconv.ParseInt(roleId, 10, 64)
		name := GetRoleName(tenantId, id)
		names = names + name + ","
	}
	if len(names) > 0 {
		return names[:len(names)-1]
	}
	return names
}

func GetRoleName(tenantId string, roleId int64) string {
	var name string
	key := fmt.Sprintf(RoleNameKey, tenantId, roleId)
	name, err := Redis.Get(key).Result()
	if err != nil {
		role := &system.Role{ID: roleId}
		if err := role.GetRole(); err != nil {
			fmt.Printf("GetRole err = %s \n", err)
		} else {
			name = role.RoleName
			Redis.Set(key, name, -1)
		}
	}
	return name
}