xps-server-go/cache/redis.go

package cache

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/go-redis/redis/v8"
	"log"
	"strings"
	"sync"
	"time"
    "xps/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 *viewmodel.UserData) error {
	keyStr := fmt.Sprintf("user_%d", userId)
	return SetCache(keyStr, userData, 0)
}

func GetUserData(userId int64) (*viewmodel.UserData, error) {
	keyStr := fmt.Sprintf("user_%d", userId)
	userData := &viewmodel.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 *viewmodel.ModelObjectInfo) error {
	keyStr := fmt.Sprintf("model_object_%s", objectCode)
	return SetCache(keyStr, data, 0)
}

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


func SetModelObjectAttrs(objectCode string, data []viewmodel.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)([]viewmodel.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([]viewmodel.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 *viewmodel.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)(*viewmodel.ModelObjectOAMInfo, error){
	keyStr := fmt.Sprintf("model_object_oam_%s_%s", objectCode, oamCode)
	oamData := &viewmodel.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 *viewmodel.BizObjectInfo) error {
	keyStr := fmt.Sprintf("biz_object_%s", objectCode)
	return SetCache(keyStr, data, 0)
}

// GetBizObject : Biz Object
func GetBizObject(objectCode string)(*viewmodel.BizObjectInfo, error){
	keyStr := fmt.Sprintf("biz_object_%s", objectCode)
	bizObjectInfo := &viewmodel.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 []viewmodel.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)([]viewmodel.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([]viewmodel.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 *viewmodel.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)(*viewmodel.BizObjectOAMInfo, error){
	keyStr := fmt.Sprintf("biz_object_oam_%s_%s", objectCode, oamCode)
	oamData := &viewmodel.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 []viewmodel.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)([]viewmodel.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([]viewmodel.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 []viewmodel.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)([]viewmodel.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([]viewmodel.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 []viewmodel.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)([]viewmodel.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([]viewmodel.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 []viewmodel.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)([]viewmodel.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([]viewmodel.BizObjectMappingInfo, 0)
	err2 := json.Unmarshal(bytes, &dataList)
	if err2 != nil {
		return nil, err2
	}
	return dataList, nil
}

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

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