You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
498 lines
12 KiB
498 lines
12 KiB
package dao |
|
|
|
import ( |
|
"context" |
|
"fmt" |
|
"strconv" |
|
|
|
"go-common/app/service/main/member/model" |
|
"go-common/library/cache/memcache" |
|
"go-common/library/log" |
|
|
|
"github.com/pkg/errors" |
|
) |
|
|
|
const ( |
|
_expPrefix = "exp_%d" |
|
_moralPrefix = "moral_%d" |
|
_expExpire = 86400 |
|
) |
|
|
|
func expKey(mid int64) string { |
|
return fmt.Sprintf(_expPrefix, mid) |
|
} |
|
|
|
func moralKey(mid int64) string { |
|
return fmt.Sprintf(_moralPrefix, mid) |
|
} |
|
|
|
// pingMC ping memcache. |
|
func (d *Dao) pingMC(c context.Context) (err error) { |
|
conn := d.mc.Get(c) |
|
defer conn.Close() |
|
if err = conn.Set(&memcache.Item{ |
|
Key: "ping", |
|
Value: []byte{1}, |
|
Expiration: 86400, |
|
}); err != nil { |
|
log.Error("conn.Set(ping, 1) error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// -------- base --------- // |
|
|
|
// BaseInfoCache get base info from mc. |
|
func (d *Dao) BaseInfoCache(c context.Context, mid int64) (info *model.BaseInfo, err error) { |
|
key := fmt.Sprintf(model.CacheKeyBase, mid) |
|
conn := d.mc.Get(c) |
|
defer conn.Close() |
|
item, err := conn.Get(key) |
|
if err != nil { |
|
if err == memcache.ErrNotFound { |
|
err = nil |
|
return |
|
} |
|
log.Error("conn.Get(%s) error(%v)", key, err) |
|
return |
|
} |
|
info = &model.BaseInfo{} |
|
if err = conn.Scan(item, info); err != nil { |
|
log.Error("conn.Scan(%s) error(%v)", string(item.Value), err) |
|
} |
|
return |
|
} |
|
|
|
// BatchBaseInfoCache get batch base info from mc. |
|
func (d *Dao) BatchBaseInfoCache(c context.Context, mids []int64) (cached map[int64]*model.BaseInfo, missed []int64, err error) { |
|
cached = make(map[int64]*model.BaseInfo, len(mids)) |
|
if len(mids) == 0 { |
|
return |
|
} |
|
keys := make([]string, 0, len(mids)) |
|
midmap := make(map[string]int64, len(mids)) |
|
for _, mid := range mids { |
|
k := fmt.Sprintf(model.CacheKeyBase, mid) |
|
keys = append(keys, k) |
|
midmap[k] = mid |
|
} |
|
conn := d.mc.Get(c) |
|
defer conn.Close() |
|
bases, err := conn.GetMulti(keys) |
|
if err != nil { |
|
log.Error("conn.Gets(%v) error(%v)", keys, err) |
|
return |
|
} |
|
for _, base := range bases { |
|
b := &model.BaseInfo{} |
|
if err = conn.Scan(base, b); err != nil { |
|
log.Error("json.Unmarshal(%v) error(%v)", base.Value, err) |
|
return |
|
} |
|
cached[midmap[base.Key]] = b |
|
delete(midmap, base.Key) |
|
} |
|
missed = make([]int64, 0, len(midmap)) |
|
for _, bid := range midmap { |
|
missed = append(missed, bid) |
|
} |
|
return |
|
|
|
} |
|
|
|
// SetBatchBaseInfoCache set batch base info to mc. |
|
func (d *Dao) SetBatchBaseInfoCache(c context.Context, bs []*model.BaseInfo) (err error) { |
|
for _, info := range bs { |
|
d.SetBaseInfoCache(c, info.Mid, info) |
|
} |
|
return |
|
} |
|
|
|
// SetBaseInfoCache set base info to mc |
|
func (d *Dao) SetBaseInfoCache(c context.Context, mid int64, info *model.BaseInfo) (err error) { |
|
key := fmt.Sprintf(model.CacheKeyBase, mid) |
|
conn := d.mc.Get(c) |
|
defer conn.Close() |
|
if err = conn.Set(&memcache.Item{ |
|
Key: key, |
|
Object: info, |
|
Flags: memcache.FlagProtobuf, |
|
Expiration: d.baseTTL, |
|
}); err != nil { |
|
log.Error("conn.Set(%s, %v) error(%v)", key, info, err) |
|
} |
|
return |
|
} |
|
|
|
// DelBaseInfoCache delete baseInfo cache. |
|
func (d *Dao) DelBaseInfoCache(c context.Context, mid int64) (err error) { |
|
key := fmt.Sprintf(model.CacheKeyBase, mid) |
|
conn := d.mc.Get(c) |
|
defer conn.Close() |
|
if err = conn.Delete(key); err != nil { |
|
if err == memcache.ErrNotFound { |
|
err = nil |
|
return |
|
} |
|
log.Error("conn.Delete(%s) error(%v)", key, err) |
|
} |
|
return |
|
} |
|
|
|
// -------- base --------- // |
|
|
|
// ----- exp ------ // |
|
|
|
// Exp get user exp from cache,if miss get from db. |
|
func (d *Dao) expCache(c context.Context, mid int64) (exp int64, err error) { |
|
key := expKey(mid) |
|
conn := d.mc.Get(c) |
|
res, err := conn.Get(key) |
|
defer conn.Close() |
|
if err != nil { |
|
return |
|
} |
|
exp, _ = strconv.ParseInt(string(res.Value), 10, 64) |
|
return |
|
} |
|
|
|
// ExpsCache get users exp cache. |
|
func (d *Dao) expsCache(c context.Context, mids []int64) (exps map[int64]int64, miss []int64, err error) { |
|
var keys []string |
|
for _, mid := range mids { |
|
keys = append(keys, expKey(mid)) |
|
} |
|
conn := d.mc.Get(c) |
|
defer conn.Close() |
|
its, err := conn.GetMulti(keys) |
|
if err != nil { |
|
return |
|
} |
|
exps = make(map[int64]int64) |
|
for _, mid := range mids { |
|
if it, ok := its[expKey(mid)]; ok { |
|
exp, _ := strconv.ParseInt(string(it.Value), 10, 64) |
|
exps[mid] = exp |
|
} else { |
|
miss = append(miss, mid) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// SetExpCache set user exp cache. |
|
func (d *Dao) SetExpCache(c context.Context, mid, exp int64) (err error) { |
|
conn := d.mc.Get(c) |
|
defer conn.Close() |
|
if err = conn.Set(&memcache.Item{ |
|
Key: expKey(mid), |
|
Value: []byte(strconv.FormatInt(exp, 10)), |
|
Expiration: _expExpire, |
|
}); err != nil { |
|
err = errors.WithStack(err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// moralCache get moral from cache. |
|
func (d *Dao) moralCache(c context.Context, mid int64) (moral *model.Moral, err error) { |
|
key := moralKey(mid) |
|
conn := d.mc.Get(c) |
|
item, err := conn.Get(key) |
|
defer conn.Close() |
|
if err != nil { |
|
return |
|
} |
|
moral = &model.Moral{} |
|
if err = conn.Scan(item, moral); err != nil { |
|
log.Error("conn.Scan(%s) error(%v)", string(item.Value), err) |
|
} |
|
return |
|
} |
|
|
|
// SetMoralCache set moral to mc |
|
func (d *Dao) SetMoralCache(c context.Context, mid int64, moral *model.Moral) (err error) { |
|
key := moralKey(mid) |
|
conn := d.mc.Get(c) |
|
defer conn.Close() |
|
if conn.Set(&memcache.Item{ |
|
Key: key, |
|
Object: moral, |
|
Flags: memcache.FlagProtobuf, |
|
Expiration: d.moralTTL, |
|
}); err != nil { |
|
log.Error("conn.Set(%s, %v) error(%v)", key, moral, err) |
|
} |
|
return |
|
} |
|
|
|
// DelMoralCache delete moral cache. |
|
func (d *Dao) DelMoralCache(c context.Context, mid int64) (err error) { |
|
key := moralKey(mid) |
|
conn := d.mc.Get(c) |
|
defer conn.Close() |
|
if err = conn.Delete(key); err != nil { |
|
if err == memcache.ErrNotFound { |
|
err = nil |
|
return |
|
} |
|
log.Error("DelMoralCache conn.Delete(%s) error(%v)", key, err) |
|
} |
|
return |
|
} |
|
|
|
// ------realname------ |
|
func realnameInfoKey(mid int64) string { |
|
return fmt.Sprintf("realname_info_%d", mid) |
|
} |
|
|
|
func realnameCaptureTimesKey(mid int64) string { |
|
return fmt.Sprintf("realname_cap_times_%d", mid) |
|
} |
|
|
|
func realnameCaptureCodeKey(mid int64) string { |
|
return fmt.Sprintf("realname_cap_code_%d", mid) |
|
} |
|
|
|
func realnameCaptureErrTimesKey(mid int64) string { |
|
return fmt.Sprintf("realname_cap_err_times%d", mid) |
|
} |
|
|
|
// RealnameCaptureTimesCache is |
|
func (d *Dao) RealnameCaptureTimesCache(c context.Context, mid int64) (times int, err error) { |
|
var ( |
|
key = realnameCaptureTimesKey(mid) |
|
conn = d.mc.Get(c) |
|
item *memcache.Item |
|
) |
|
defer conn.Close() |
|
if item, err = conn.Get(key); err != nil { |
|
if err == memcache.ErrNotFound { |
|
err = nil |
|
times = -1 |
|
return |
|
} |
|
err = errors.Wrapf(err, "conn.Get(%s)", key) |
|
return |
|
} |
|
if err = conn.Scan(item, ×); err != nil { |
|
err = errors.Wrapf(err, "conn.Scan(%+v)", item) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// IncreaseRealnameCaptureTimes is |
|
func (d *Dao) IncreaseRealnameCaptureTimes(c context.Context, mid int64) (err error) { |
|
var ( |
|
key = realnameCaptureTimesKey(mid) |
|
conn = d.mc.Get(c) |
|
) |
|
defer conn.Close() |
|
if _, err = conn.Increment(key, 1); err != nil { |
|
err = errors.Wrapf(err, "conn.Increment(%s,1)", key) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// SetRealnameCaptureTimes is |
|
func (d *Dao) SetRealnameCaptureTimes(c context.Context, mid int64, times int) (err error) { |
|
var ( |
|
key = realnameCaptureTimesKey(mid) |
|
conn = d.mc.Get(c) |
|
) |
|
defer conn.Close() |
|
if err = conn.Set(&memcache.Item{Key: key, Object: times, Flags: memcache.FlagJSON, Expiration: d.captureTimesTTL}); err != nil { |
|
err = errors.Wrapf(err, "conn.Set(%s,%+v)", key, times) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// RealnameCaptureCodeCache . |
|
// return code : -1 , if code not found |
|
// RealnameCaptureCodeCache is |
|
func (d *Dao) RealnameCaptureCodeCache(c context.Context, mid int64) (code int, err error) { |
|
var ( |
|
key = realnameCaptureCodeKey(mid) |
|
conn = d.mc.Get(c) |
|
item *memcache.Item |
|
) |
|
defer conn.Close() |
|
if item, err = conn.Get(key); err != nil { |
|
if err == memcache.ErrNotFound { |
|
err = nil |
|
code = -1 |
|
return |
|
} |
|
err = errors.Wrapf(err, "conn.Get(%s)", key) |
|
return |
|
} |
|
if err = conn.Scan(item, &code); err != nil { |
|
err = errors.Wrapf(err, "conn.Scan(%+v)", item) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// RealnameInfoCache is. |
|
func (d *Dao) RealnameInfoCache(c context.Context, mid int64) (info *model.RealnameCacheInfo, err error) { |
|
var ( |
|
key = realnameInfoKey(mid) |
|
conn = d.mc.Get(c) |
|
item *memcache.Item |
|
) |
|
defer conn.Close() |
|
if item, err = conn.Get(key); err != nil { |
|
if err == memcache.ErrNotFound { |
|
err = nil |
|
info = nil |
|
return |
|
} |
|
err = errors.Wrapf(err, "conn.Get(%s)", key) |
|
return |
|
} |
|
info = &model.RealnameCacheInfo{} |
|
if err = conn.Scan(item, &info); err != nil { |
|
err = errors.Wrapf(err, "conn.Scan(%+v)", item) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// SetRealnameInfo is. |
|
func (d *Dao) SetRealnameInfo(c context.Context, mid int64, info *model.RealnameCacheInfo) (err error) { |
|
var ( |
|
key = realnameInfoKey(mid) |
|
conn = d.mc.Get(c) |
|
) |
|
defer conn.Close() |
|
if err = conn.Set(&memcache.Item{Key: key, Object: info, Flags: memcache.FlagJSON, Expiration: d.applyInfoTTL}); err != nil { |
|
err = errors.Wrapf(err, "conn.Set(%s,%+v)", key, info) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// SetRealnameCaptureCode is |
|
func (d *Dao) SetRealnameCaptureCode(c context.Context, mid int64, code int) (err error) { |
|
var ( |
|
key = realnameCaptureCodeKey(mid) |
|
conn = d.mc.Get(c) |
|
) |
|
defer conn.Close() |
|
if err = conn.Set(&memcache.Item{Key: key, Object: code, Flags: memcache.FlagJSON, Expiration: d.captureCodeTTL}); err != nil { |
|
err = errors.Wrapf(err, "conn.Set(%s,%+v)", key, code) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// DeleteRealnameCaptureCode is |
|
func (d *Dao) DeleteRealnameCaptureCode(c context.Context, mid int64) (err error) { |
|
var ( |
|
key = realnameCaptureCodeKey(mid) |
|
conn = d.mc.Get(c) |
|
) |
|
defer conn.Close() |
|
if err = conn.Delete(key); err != nil { |
|
if err == memcache.ErrNotFound { |
|
err = nil |
|
return |
|
} |
|
err = errors.Wrapf(err, "conn.Delete(%s)", key) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// DeleteRealnameInfo is |
|
func (d *Dao) DeleteRealnameInfo(c context.Context, mid int64) (err error) { |
|
var ( |
|
key = realnameInfoKey(mid) |
|
conn = d.mc.Get(c) |
|
) |
|
defer conn.Close() |
|
if err = conn.Delete(key); err != nil { |
|
if err == memcache.ErrNotFound { |
|
err = nil |
|
return |
|
} |
|
err = errors.Wrapf(err, "conn.Delete(%s)", key) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// RealnameCaptureErrTimesCache is |
|
func (d *Dao) RealnameCaptureErrTimesCache(c context.Context, mid int64) (times int, err error) { |
|
var ( |
|
key = realnameCaptureErrTimesKey(mid) |
|
conn = d.mc.Get(c) |
|
item *memcache.Item |
|
) |
|
defer conn.Close() |
|
if item, err = conn.Get(key); err != nil { |
|
if err == memcache.ErrNotFound { |
|
err = nil |
|
times = -1 |
|
return |
|
} |
|
err = errors.Wrapf(err, "conn.Get(%s)", key) |
|
return |
|
} |
|
if err = conn.Scan(item, ×); err != nil { |
|
err = errors.Wrapf(err, "conn.Scan(%+v)", item) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// SetRealnameCaptureErrTimes is |
|
func (d *Dao) SetRealnameCaptureErrTimes(c context.Context, mid int64, times int) (err error) { |
|
var ( |
|
key = realnameCaptureErrTimesKey(mid) |
|
conn = d.mc.Get(c) |
|
) |
|
defer conn.Close() |
|
if err = conn.Set(&memcache.Item{Key: key, Object: times, Flags: memcache.FlagJSON, Expiration: d.captureErrTimesTTL}); err != nil { |
|
err = errors.Wrapf(err, "conn.Set(%s,%+v)", key, times) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// IncreaseRealnameCaptureErrTimes is |
|
func (d *Dao) IncreaseRealnameCaptureErrTimes(c context.Context, mid int64) (err error) { |
|
var ( |
|
key = realnameCaptureErrTimesKey(mid) |
|
conn = d.mc.Get(c) |
|
) |
|
defer conn.Close() |
|
if _, err = conn.Increment(key, 1); err != nil { |
|
err = errors.Wrapf(err, "conn.Increment(%s,1)", key) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// DeleteRealnameCaptureErrTimes is |
|
func (d *Dao) DeleteRealnameCaptureErrTimes(c context.Context, mid int64) (err error) { |
|
var ( |
|
key = realnameCaptureErrTimesKey(mid) |
|
conn = d.mc.Get(c) |
|
) |
|
defer conn.Close() |
|
if err = conn.Delete(key); err != nil { |
|
if err == memcache.ErrNotFound { |
|
err = nil |
|
err = nil |
|
return |
|
} |
|
err = errors.Wrapf(err, "conn.Delete(%s)", key) |
|
return |
|
} |
|
return |
|
}
|
|
|