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.
113 lines
2.6 KiB
113 lines
2.6 KiB
package dao |
|
|
|
import ( |
|
"context" |
|
"encoding/json" |
|
"net/url" |
|
"strconv" |
|
"time" |
|
|
|
"go-common/app/service/main/member/model" |
|
"go-common/library/cache/memcache" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
) |
|
|
|
const ( |
|
_expLogID = 11 |
|
) |
|
|
|
// Exp get user exp from cache,if miss get from db. |
|
func (d *Dao) Exp(c context.Context, mid int64) (exp int64, err error) { |
|
if exp, err = d.expCache(c, mid); err == nil { |
|
return |
|
} |
|
if err != nil && err != memcache.ErrNotFound { |
|
return |
|
} |
|
if exp, err = d.ExpDB(c, mid); err != nil { |
|
return |
|
} |
|
d.SetExpCache(c, mid, exp) |
|
return |
|
} |
|
|
|
// Exps get exps by mids. |
|
func (d *Dao) Exps(c context.Context, mids []int64) (exps map[int64]int64, err error) { |
|
exps, miss, err := d.expsCache(c, mids) |
|
if err != nil { |
|
return |
|
} |
|
if len(miss) == 0 { |
|
return |
|
} |
|
for _, mid := range miss { |
|
mid := mid |
|
exp, err := d.ExpDB(c, mid) |
|
if err != nil { |
|
log.Error("exp mid %d err %v", mid, err) |
|
err = nil |
|
continue |
|
} |
|
exps[mid] = exp |
|
d.cache.Do(c, func(ctx context.Context) { |
|
d.SetExpCache(ctx, mid, exp) |
|
}) |
|
} |
|
return |
|
} |
|
|
|
// ExpLog is |
|
func (d *Dao) ExpLog(ctx context.Context, mid int64, ip string) ([]*model.UserLog, error) { |
|
t := time.Now().Add(-time.Hour * 24 * 7) |
|
params := url.Values{} |
|
params.Set("mid", strconv.FormatInt(mid, 10)) |
|
params.Set("appid", "log_user_action") |
|
params.Set("business", strconv.FormatInt(_expLogID, 10)) |
|
params.Set("pn", "1") |
|
params.Set("ps", "1000") |
|
params.Set("ctime_from", t.Format("2006-01-02 00:00:00")) |
|
params.Set("sort", "desc") |
|
params.Set("order", "ctime") |
|
|
|
res := &model.SearchResult{} |
|
if err := d.client.Get(ctx, d.c.Host.Search+_searchLogURI, ip, params, res); err != nil { |
|
return nil, err |
|
} |
|
if res.Code != 0 { |
|
return nil, ecode.Int(res.Code) |
|
} |
|
logs := asExpLog(res) |
|
return logs, nil |
|
} |
|
|
|
func asExpLog(res *model.SearchResult) []*model.UserLog { |
|
logs := make([]*model.UserLog, 0, len(res.Data.Result)) |
|
for _, r := range res.Data.Result { |
|
ts, err := time.ParseInLocation("2006-01-02 15:04:05", r.Ctime, time.Local) |
|
if err != nil { |
|
log.Warn("Failed to parse log ctime: ctime: %s: %+v", r.Ctime, err) |
|
continue |
|
} |
|
content := map[string]string{ |
|
"from_exp": "", |
|
"operater": "", |
|
"reason": "", |
|
"to_exp": "", |
|
"log_id": "", |
|
} |
|
if err := json.Unmarshal([]byte(r.ExtraData), &content); err != nil { |
|
log.Warn("Failed to parse extra data in exp log: mid: %d, extra_data: %s: %+v", r.Mid, r.ExtraData, err) |
|
continue |
|
} |
|
l := &model.UserLog{ |
|
Mid: r.Mid, |
|
IP: r.IP, |
|
TS: ts.Unix(), |
|
LogID: content["log_id"], |
|
Content: content, |
|
} |
|
logs = append(logs, l) |
|
} |
|
return logs |
|
}
|
|
|