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

package cache

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

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

    // 初始化配置数据到缓存
    InitCacheData()
}

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