xps-server-g5/cmd/cache/redis/redis.go

package redis

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/go-redis/redis/v8"
	"log"
	"strings"
	"sync"
	"time"
	apiViewModel "xps/pkg/api/viewmodel"
	bizViewModel "xps/pkg/biz/viewmodel"
	modelViewModel "xps/pkg/model/viewmodel"
	sysViewModel "xps/pkg/system/viewmodel"
)

var ErrRedisInit = errors.New("缓存初始化失败")
var (
	once        sync.Once
	cacheClient redis.UniversalClient
)

var CONFIG = Redis{
	DB:       0,
	Addr:     "127.0.0.1:6379",
	Password: "",
	PoolSize: 0,
}

type Redis struct {
	DB       int    `mapstructure:"db"        json:"db"        yaml:"db"`
	Addr     string `mapstructure:"addr"      json:"addr"      yaml:"addr"`
	Password string `mapstructure:"password"  json:"password"  yaml:"password"`
	PoolSize int    `mapstructure:"pool-size" json:"pool-size" yaml:"pool-size"`
}

func init() {
	if Instance() == nil {
		log.Fatal(ErrRedisInit)
	}
}

func Instance() redis.UniversalClient {
	once.Do(func() {
		universalOptions := &redis.UniversalOptions{
			Addrs:       strings.Split(CONFIG.Addr, ","),
			Password:    CONFIG.Password,
			PoolSize:    int(CONFIG.PoolSize),
			IdleTimeout: 300 * time.Second,
		}
		cacheClient = redis.NewUniversalClient(universalOptions)
	})

	return cacheClient
}

func SetCache(key string, value interface{}, expiration time.Duration) error {
	err := Instance().Set(context.Background(), key, value, expiration).Err()
	if err != nil {
		return err
	}
	return nil
}

func GetCache(key string) (interface{}, error) {
	return Instance().Get(context.Background(), key).Result()
}

func DeleteCache(key string) (int64, error) {
	return Instance().Del(context.Background(), key).Result()
}

func GetCacheString(key string) (string, error) {
	value, err := GetCacheBytes(key)
	if err != nil {
		return "", err
	}
	return string(value), nil
}

func GetCacheBytes(key string) ([]byte, error) {
	return Instance().Get(context.Background(), key).Bytes()
}

func GetCacheUint(key string) (uint64, error) {
	return Instance().Get(context.Background(), key).Uint64()
}

func SetUserData(userId int64, userData *sysViewModel.UserData) error {
	keyStr := fmt.Sprintf("user_%d", userId)
	return SetCache(keyStr, userData, 0)
}

func GetUserData(userId int64) (*sysViewModel.UserData, error) {
	keyStr := fmt.Sprintf("user_%d", userId)
	userData := &sysViewModel.UserData{}
	err := Instance().Get(context.Background(), keyStr).Scan(userData)
	if err != nil {
		return nil, err
	}
	return userData, nil
}

func DeleteUserData(userId int64) (int64, error) {
	keyStr := fmt.Sprintf("user_%d", userId)
	return Instance().Del(context.Background(), keyStr).Result()
}

func SetModelObject(objectCode string, data *modelViewModel.ModelObjectInfo) error {
	keyStr := fmt.Sprintf("model_object_%s", objectCode)
	return SetCache(keyStr, data, 0)
}

func GetModelObject(objectCode string) (*modelViewModel.ModelObjectInfo, error) {
	keyStr := fmt.Sprintf("model_object_%s", objectCode)
	modelObjectInfo := &modelViewModel.ModelObjectInfo{}
	err := Instance().Get(context.Background(), keyStr).Scan(modelObjectInfo)
	if err != nil {
		return nil, err
	}
	return modelObjectInfo, nil
}

func SetModelObjectAttrs(objectCode string, data []modelViewModel.ModelObjectAttrInfo) error {
	keyStr := fmt.Sprintf("model_object_attr_%s", objectCode)
	dataList, _ := json.Marshal(data)
	err := Instance().Set(context.Background(), keyStr, dataList, 0).Err()
	if err != nil {
		return err
	}
	return nil
}

func GetModelObjectAttrs(objectCode string) ([]modelViewModel.ModelObjectAttrInfo, error) {
	keyStr := fmt.Sprintf("model_object_attr_%s", objectCode)

	bytes, err := Instance().Get(context.Background(), keyStr).Bytes()
	if err != nil {
		return nil, err
	}

	modelObjectAttrInfo := make([]modelViewModel.ModelObjectAttrInfo, 0)
	err = json.Unmarshal(bytes, &modelObjectAttrInfo)
	if err != nil {
		return nil, err
	}
	return modelObjectAttrInfo, nil
}

// SetModelObjectOAM : Model Object OAM
func SetModelObjectOAM(objectCode, oamCode string, data *modelViewModel.ModelObjectOAMInfo) error {
	keyStr := fmt.Sprintf("model_object_oam_%s_%s", objectCode, oamCode)
	return SetCache(keyStr, data, 0)
}

// GetModelObjectOAM : Model Object OAM
func GetModelObjectOAM(objectCode, oamCode string) (*modelViewModel.ModelObjectOAMInfo, error) {
	keyStr := fmt.Sprintf("model_object_oam_%s_%s", objectCode, oamCode)
	oamData := &modelViewModel.ModelObjectOAMInfo{}
	err := Instance().Get(context.Background(), keyStr).Scan(oamData)
	if err != nil {
		return nil, err
	}
	return oamData, nil
}

// SetBizObject : Biz Object
func SetBizObject(objectCode string, data *bizViewModel.BizObjectInfo) error {
	keyStr := fmt.Sprintf("biz_object_%s", objectCode)
	return SetCache(keyStr, data, 0)
}

// GetBizObject : Biz Object
func GetBizObject(objectCode string) (*bizViewModel.BizObjectInfo, error) {
	keyStr := fmt.Sprintf("biz_object_%s", objectCode)
	bizObjectInfo := &bizViewModel.BizObjectInfo{}
	err := Instance().Get(context.Background(), keyStr).Scan(bizObjectInfo)
	if err != nil {
		return nil, err
	}
	return bizObjectInfo, nil
}

// SetBizObjectAttrs : Biz Object Attrs
func SetBizObjectAttrs(objectCode string, data []bizViewModel.BizObjectAttrInfo) error {
	keyStr := fmt.Sprintf("biz_object_attrs_%s", objectCode)
	dataList, _ := json.Marshal(data)
	err := Instance().Set(context.Background(), keyStr, dataList, 0).Err()
	if err != nil {
		return err
	}
	return nil
}

// GetBizObjectAttrs : Biz Object Attrs
func GetBizObjectAttrs(objectCode string) ([]bizViewModel.BizObjectAttrInfo, error) {
	keyStr := fmt.Sprintf("biz_object_attrs_%s", objectCode)

	bytes, err := Instance().Get(context.Background(), keyStr).Bytes()
	if err != nil {
		return nil, err
	}

	bizObjectAttrs := make([]bizViewModel.BizObjectAttrInfo, 0)
	err2 := json.Unmarshal(bytes, &bizObjectAttrs)
	if err2 != nil {
		return nil, err2
	}
	return bizObjectAttrs, nil
}

// SetBizObjectOAM : Biz Object OAM
func SetBizObjectOAM(objectCode, oamCode string, data *bizViewModel.BizObjectOAMInfo) error {
	keyStr := fmt.Sprintf("biz_object_oam_%s_%s", objectCode, oamCode)
	return SetCache(keyStr, data, 0)
}

// GetBizObjectOAM : Biz Object OAM
func GetBizObjectOAM(objectCode, oamCode string) (*bizViewModel.BizObjectOAMInfo, error) {
	keyStr := fmt.Sprintf("biz_object_oam_%s_%s", objectCode, oamCode)
	oamData := &bizViewModel.BizObjectOAMInfo{}
	err := Instance().Get(context.Background(), keyStr).Scan(oamData)
	if err != nil {
		return nil, err
	}
	return oamData, nil
}

// SetBizObjectOAMRules : Biz Object OAM Rules
func SetBizObjectOAMRules(objectCode, oamCode string, data []bizViewModel.BizObjectOAMRuleInfo) error {
	keyStr := fmt.Sprintf("biz_object_oam_rules_%s_%s", objectCode, oamCode)
	dataList, _ := json.Marshal(data)
	err := Instance().Set(context.Background(), keyStr, dataList, 0).Err()
	if err != nil {
		return err
	}
	return nil
}

// GetBizObjectOAMRules : Biz Object OAM Rules
func GetBizObjectOAMRules(objectCode, oamCode string) ([]bizViewModel.BizObjectOAMRuleInfo, error) {
	keyStr := fmt.Sprintf("biz_object_oam_rules_%s_%s", objectCode, oamCode)
	bytes, err1 := Instance().Get(context.Background(), keyStr).Bytes()
	if err1 != nil {
		return nil, err1
	}

	dataList := make([]bizViewModel.BizObjectOAMRuleInfo, 0)
	err2 := json.Unmarshal(bytes, &dataList)
	if err2 != nil {
		return nil, err2
	}
	return dataList, nil
}

// SetBizObjectOAMParams : Biz Object OAM Params
func SetBizObjectOAMParams(objectCode, oamCode string, data []bizViewModel.BizObjectOAMParamsInfo) error {
	keyStr := fmt.Sprintf("biz_object_oam_params_%s_%s", objectCode, oamCode)
	dataList, _ := json.Marshal(data)
	err := Instance().Set(context.Background(), keyStr, dataList, 0).Err()
	if err != nil {
		return err
	}
	return nil
}

// GetBizObjectOAMParams : Biz Object OAM Params
func GetBizObjectOAMParams(objectCode, oamCode string) ([]bizViewModel.BizObjectOAMParamsInfo, error) {
	keyStr := fmt.Sprintf("biz_object_oam_params_%s_%s", objectCode, oamCode)
	bytes, err1 := Instance().Get(context.Background(), keyStr).Bytes()
	if err1 != nil {
		return nil, err1
	}

	dataList := make([]bizViewModel.BizObjectOAMParamsInfo, 0)
	err2 := json.Unmarshal(bytes, &dataList)
	if err2 != nil {
		return nil, err2
	}
	return dataList, nil
}

// SetBizObjectOAMMapping : Biz Object OAM Mapping
func SetBizObjectOAMMapping(objectCode, oamCode string, data []bizViewModel.BizObjectOAMMappingInfo) error {
	keyStr := fmt.Sprintf("biz_object_oam_mapping_%s_%s", objectCode, oamCode)
	dataList, _ := json.Marshal(data)
	err := Instance().Set(context.Background(), keyStr, dataList, 0).Err()
	if err != nil {
		return err
	}
	return nil
}

// GetBizObjectOAMMapping : Biz Object OAM Mapping
func GetBizObjectOAMMapping(objectCode, oamCode string) ([]bizViewModel.BizObjectOAMMappingInfo, error) {
	keyStr := fmt.Sprintf("biz_object_oam_mapping_%s_%s", objectCode, oamCode)
	bytes, err1 := Instance().Get(context.Background(), keyStr).Bytes()
	if err1 != nil {
		return nil, err1
	}

	dataList := make([]bizViewModel.BizObjectOAMMappingInfo, 0)
	err2 := json.Unmarshal(bytes, &dataList)
	if err2 != nil {
		return nil, err2
	}
	return dataList, nil
}

// SetBizObjectMapping : Biz Object Mapping
func SetBizObjectMapping(objectCode string, data []bizViewModel.BizObjectMappingInfo) error {
	keyStr := fmt.Sprintf("biz_object_mapping_%s", objectCode)
	dataList, _ := json.Marshal(data)
	err := Instance().Set(context.Background(), keyStr, dataList, 0).Err()
	if err != nil {
		return err
	}
	return nil
}

// GetBizObjectMapping : Biz Object Mapping
func GetBizObjectMapping(objectCode string) ([]bizViewModel.BizObjectMappingInfo, error) {
	keyStr := fmt.Sprintf("biz_object_mapping_%s", objectCode)
	bytes, err1 := Instance().Get(context.Background(), keyStr).Bytes()
	if err1 != nil {
		return nil, err1
	}

	dataList := make([]bizViewModel.BizObjectMappingInfo, 0)
	err2 := json.Unmarshal(bytes, &dataList)
	if err2 != nil {
		return nil, err2
	}
	return dataList, nil
}

func SetApiData(objectCode, oamCode string, data *apiViewModel.ApiInfo) error {
	keyStr := fmt.Sprintf("api_%s_%s", objectCode, oamCode)
	return SetCache(keyStr, data, 0)
}

func GetApiData(objectCode, oamCode string) (*apiViewModel.ApiInfo, error) {
	keyStr := fmt.Sprintf("api_%s_%s", objectCode, oamCode)
	apiData := &apiViewModel.ApiInfo{}
	err := Instance().Get(context.Background(), keyStr).Scan(apiData)
	if err != nil {
		return nil, err
	}
	return apiData, nil
}