web_huangguo2_h5/pub/redis/redis.go

package redis

import (
	"errors"
	"fmt"
	"time"
	sErr "videoweb/pub/common/errors"
	"videoweb/pub/common/log"

	goredis "github.com/go-redis/redis"
)

type ZMember = goredis.Z

// Set 设置键值对
func Set(key string, value interface{}, expireTime time.Duration) (err error) {
	if err = redisCli.Set(key, value, expireTime).Err(); err != nil {
		return sErr.MakeWithErr(sErr.RedisSet, err)
	}
	return
}

// Incr 增加1
func Incr(key string, expireTime time.Duration) (val int64, err error) {
	val, err = redisCli.Incr(key).Result()
	if err != nil {
		return
	}
	duration := redisCli.TTL(key).Val()
	//log.Info("Incr Test", log.Any("duration", duration))
	if duration.Seconds() == -1 {
		redisCli.Expire(key, expireTime)
	}
	return
}

func SAdd(key string, members ...interface{}) (err error) {
	_, err = redisCli.SAdd(key, members...).Result()
	return
}

// 无序集合操作  随机删除集合中某一元素
func SPop(key string, members ...interface{}) (string, error) {
	val, err := redisCli.SPop(key).Result()
	if err != nil {
		log.Error(fmt.Sprintf("SPop failed %+v:", err))
	}
	return val, err
}

func SRem(key string, members ...interface{}) (err error) {
	if err = redisCli.SRem(key, members...).Err(); err != nil {
		err = sErr.MakeWithErr(sErr.RedisSet, err)
	}
	return
}

// ScanSlice 返回集合成员
func SScanSlice(key string, container interface{}) (err error) {
	err = redisCli.SMembers(key).ScanSlice(container)
	return err
}

// SMembers
func SMembers(key string) (list []string, err error) {
	result := redisCli.SMembers(key)
	if result.Err() != nil {
		err = sErr.MakeWithErr(sErr.RedisGet, result.Err())
		return
	}
	list = result.Val()
	return
}

// RPush
func RPush(key string, value string) error {
	if key == "" {
		return errors.New("key should not empty")
	}
	if err := redisCli.RPush(key, value).Err(); err != nil {
		return sErr.MakeWithErr(sErr.RedisRPush, err)
	}
	return nil
}

// RPush
func RPushValues(key string, value ...interface{}) error {
	if key == "" {
		return errors.New("key should not empty")
	}
	if err := redisCli.RPush(key, value...).Err(); err != nil {
		return sErr.MakeWithErr(sErr.RedisRPush, err)
	}
	return nil
}

// LPop
func LPop(key string) (*string, error) {
	if key == "" {
		return nil, errors.New("key should not empty")
	}

	cmd := redisCli.LPop(key)
	if cmd.Err() != nil {
		return nil, sErr.MakeWithErr(sErr.RedisLPop, cmd.Err())
	}

	data, err := cmd.Result()
	if err != nil {
		if err == goredis.Nil {
			return nil, nil
		}
		return nil, err
	}

	return &data, nil
}

// Get 根据键 获取值
func Get(key string) (*string, error) {
	if key == "" {
		return nil, errors.New("key should not empty")
	}
	data, err := redisCli.Get(key).Result()
	if err != nil {
		if err == goredis.Nil {
			return nil, nil
		}
		return nil, err
	} else {
		return &data, nil
	}
}

// Get 根据键 获取值
func GetBytes(key string) (bytes []byte, err error) {
	bytes, err = redisCli.Get(key).Bytes()
	if err != nil {
		return nil, sErr.MakeWithErr(sErr.RedisGet, err)
	}
	return
}

// Del 删除
func Del(keys ...string) (err error) {
	if err = redisCli.Del(keys...).Err(); err != nil {
		return sErr.MakeWithErr(sErr.RedisDel, err)
	}
	return
}

// Exists keys exists?
func Exists(keys ...string) (has bool, err error) {
	intcmd := redisCli.Exists(keys...)
	if err = intcmd.Err(); err != nil {
		return
	}
	has = intcmd.Val() > 0
	return
}

func Keys(pattern string) (keys []string, err error) {
	list := redisCli.Keys(pattern)
	keys = list.Val()
	err = list.Err()
	return
}

// Setnx 设置键值对
func Setnx(key string, value interface{}, expirTime time.Duration) (err error) {
	if err = redisCli.SetNX(key, value, expirTime).Err(); err != nil {
		err = sErr.MakeWithErr(sErr.RedisSet, err)
	}
	return
}

// Setnx 设置键值对 正确的封装
func Setnx_NewOK(key string, value interface{}, expirTime time.Duration) (v bool, err error) {
	cmd := redisCli.SetNX(key, value, expirTime)
	return cmd.Val(), cmd.Err()
}

func Expire(key string, expirTime time.Duration) (err error) {
	if err = redisCli.Expire(key, expirTime).Err(); err != nil {
		err = sErr.MakeWithErr(sErr.RedisSet, err)
	}
	return
}

// Redis `SRANDMEMBER key count` command.
func SRandMemberN(key string, count int64) (list []string, err error) {
	result := redisCli.SRandMemberN(key, count)
	if result.Err() != nil {
		return
	}
	list = result.Val()
	return
}

// 有序集合操作 添加多个有序集合
func ZAdd(key string, z ...ZMember) (int64, error) {
	count, err := redisCli.ZAdd(key, z...).Result()
	if err != nil {
		log.Error(fmt.Sprintf("ZAdd failed %+v:", err))
	}
	return count, err
}

// 有序集合 数量
func ZCard(key string) (int64, error) {
	count, err := redisCli.ZCard(key).Result()
	if err != nil {
		log.Error(fmt.Sprintf("ZCard failed %+v:", err))
	}
	return count, err
}

// 返回区间成员
func ZRange(key string, start, end int64) ([]string, error) {
	data, err := redisCli.ZRange(key, start, end).Result()
	if err != nil {
		log.Error(fmt.Sprintf("ZRange failed %+v:", err))
	}
	return data, err
}

// 按照元素排序 删除指定排名的元素
func ZRemRangeByRank(key string, start, end int64) (int64, error) {
	count, err := redisCli.ZRemRangeByRank(key, start, end).Result()
	if err != nil {
		log.Error(fmt.Sprintf("ZRemRangeByRank failed %+v:", err))
	}
	return count, err
}

// 按照元素排序 删除按指定的分数区间的的元素
func ZRemRangeByScore(key, start, end string) (int64, error) {
	count, err := redisCli.ZRemRangeByScore(key, start, end).Result()
	if err != nil {
		log.Error(fmt.Sprintf("ZRemRangeByScore failed %+v:", err))
	}
	return count, err
}

// Publish 发布消息
func Publish(channel RCType, message string) error {
	if err := redisCli.Publish(string(channel), message).Err(); err != nil {
		log.Error(fmt.Sprintf("Publish failed %+v:", err))
		return err
	}
	return nil
}

func SendMsgToTg(message string) error {
	return Publish(RCT_tgmsg_send_msg, message)
}

// SCard 发布消息
func SCard(key string) (int64, error) {
	count, err := redisCli.SCard(key).Result()
	if err != nil {
		log.Error(fmt.Sprintf("SCard failed %+v:", err))
	}

	return count, err
}

// 获取key的剩余生存时间
func TTL(key string) time.Duration {
	durCmd := redisCli.TTL(key)
	if durCmd != nil {
		return durCmd.Val()
	}
	return 0
}