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.
425 lines
11 KiB
425 lines
11 KiB
package dao |
|
|
|
import ( |
|
"bytes" |
|
"context" |
|
"fmt" |
|
"strconv" |
|
"strings" |
|
|
|
"go-common/app/interface/bbq/app-bbq/model" |
|
user "go-common/app/service/bbq/user/api" |
|
"go-common/library/log" |
|
"go-common/library/net/metadata" |
|
|
|
"github.com/json-iterator/go" |
|
) |
|
|
|
// ReplySubCursor http请求子评论游标获取评论 |
|
func (d *Dao) ReplySubCursor(c context.Context, req map[string]interface{}) (res *model.SubCursorRes, err error) { |
|
var r []byte |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
res = new(model.SubCursorRes) |
|
r, err = replyHTTPCommon(c, d.httpClient, d.c.URLs["reply_subcursor"], "GET", req, ip) |
|
if err != nil { |
|
log.Infov(c, |
|
log.KV("log", fmt.Sprintf("replyHTTPCommon err [%v]", err)), |
|
) |
|
return |
|
} |
|
var json = jsoniter.ConfigCompatibleWithStandardLibrary |
|
decoder := json.NewDecoder(bytes.NewBuffer(r)) |
|
decoder.UseNumber() |
|
err = decoder.Decode(&res) |
|
// err = json.Unmarshal(r, &res) |
|
if err != nil { |
|
log.Errorv(c, log.KV("log", fmt.Sprintf("json unmarlshal err data[%s]", string(r)))) |
|
return |
|
} |
|
//获取所有mid |
|
var mid []int64 |
|
if res.Root != nil { |
|
mid = append(mid, res.Root.Mid) |
|
} |
|
if res.Root.Replies != nil { |
|
mid = append(mid, d.getMidInReplys(res.Root.Replies)...) |
|
} |
|
//批量获取userinfo |
|
var userinfo map[int64]*user.UserBase |
|
userinfo, err = d.JustGetUserBase(c, mid) |
|
if err != nil { |
|
log.Errorv(c, log.KV("log", fmt.Sprintf("d.UserBase err[%v]", err))) |
|
return |
|
} |
|
if res.Root != nil { |
|
d.replaceMemberInReply(res.Root, userinfo) |
|
} |
|
return |
|
} |
|
|
|
// ReplyCursor http请求游标获取评论 |
|
func (d *Dao) ReplyCursor(c context.Context, req map[string]interface{}) (res *model.CursorRes, err error) { |
|
var r []byte |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
res = new(model.CursorRes) |
|
r, err = replyHTTPCommon(c, d.httpClient, d.c.URLs["reply_cursor"], "GET", req, ip) |
|
if err != nil { |
|
log.Infov(c, |
|
log.KV("log", fmt.Sprintf("replyHTTPCommon err [%v]", err)), |
|
) |
|
return |
|
} |
|
var json = jsoniter.ConfigCompatibleWithStandardLibrary |
|
decoder := json.NewDecoder(bytes.NewBuffer(r)) |
|
decoder.UseNumber() |
|
err = decoder.Decode(&res) |
|
if err != nil { |
|
log.Errorv(c, log.KV("log", fmt.Sprintf("json unmarlshal err data[%s]", string(r)))) |
|
return |
|
} |
|
//获取所有mid |
|
var mid []int64 |
|
if res.Replies != nil { |
|
mid = append(mid, d.getMidInReplys(res.Replies)...) |
|
} |
|
if res.Hots != nil { |
|
mid = append(mid, d.getMidInReplys(res.Hots)...) |
|
} |
|
if res.Top != nil { |
|
if res.Top.Admin != nil { |
|
mid = append(mid, res.Top.Admin.Mid) |
|
} |
|
if res.Top.Upper != nil { |
|
mid = append(mid, res.Top.Upper.Mid) |
|
} |
|
} |
|
//批量获取userinfo |
|
var userinfo map[int64]*user.UserBase |
|
userinfo, err = d.JustGetUserBase(c, mid) |
|
if err != nil { |
|
log.Errorv(c, log.KV("log", fmt.Sprintf("d.UserBase err[%v]", err))) |
|
return |
|
} |
|
if res.Replies != nil { |
|
d.replaceMemberInReplys(res.Replies, userinfo) |
|
} |
|
if res.Hots != nil { |
|
d.replaceMemberInReplys(res.Hots, userinfo) |
|
} |
|
if res.Top != nil { |
|
if res.Top.Admin != nil { |
|
d.replaceMemberInReplys(res.Top.Admin.Replies, userinfo) |
|
} |
|
if res.Top.Upper != nil { |
|
d.replaceMemberInReplys(res.Top.Upper.Replies, userinfo) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// getMidInReplys 批量获取评论列表中mid |
|
func (d *Dao) getMidInReplys(r []*model.Reply) (l []int64) { |
|
for _, v := range r { |
|
l = append(l, v.Mid) |
|
for _, c := range v.Content.Members { |
|
cmid, err := strconv.ParseInt(c.Mid, 10, 64) |
|
if err != nil { |
|
log.Errorv( |
|
context.Background(), |
|
log.KV("log", fmt.Sprintf("strconv err [%v] data[%s]", err, c.Mid)), |
|
) |
|
continue |
|
} |
|
l = append(l, cmid) |
|
} |
|
if len(v.Replies) > 0 { |
|
sl := d.getMidInReplys(v.Replies) |
|
l = append(l, sl...) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// replaceMemberInReplys 批量替换评论列表中用户信息 |
|
func (d *Dao) replaceMemberInReplys(r []*model.Reply, umap map[int64]*user.UserBase) { |
|
for _, v := range r { |
|
if u, ok := umap[v.Mid]; ok { |
|
v.Member.BInfo = u |
|
|
|
} else { |
|
v.Member.BInfo = new(user.UserBase) |
|
v.Member.BInfo.Mid = v.Mid |
|
v.Member.BInfo.Uname = v.Member.Name |
|
v.Member.BInfo.Face = v.Member.Avatar |
|
} |
|
for _, c := range v.Content.Members { |
|
cmid, err := strconv.ParseInt(c.Mid, 10, 64) |
|
if err != nil { |
|
log.Errorv( |
|
context.Background(), |
|
log.KV("log", fmt.Sprintf("strconv err [%v] data[%s]", err, c.Mid)), |
|
) |
|
continue |
|
} |
|
if u, ok := umap[cmid]; ok { |
|
c.BInfo = u |
|
} else { |
|
c.BInfo = new(user.UserBase) |
|
c.BInfo.Mid = cmid |
|
c.BInfo.Uname = c.Name |
|
c.BInfo.Face = c.Avatar |
|
} |
|
} |
|
if len(v.Replies) > 0 { |
|
d.replaceMemberInReplys(v.Replies, umap) |
|
} |
|
} |
|
} |
|
|
|
// replaceMemberInReply 替换评论中用户信息 |
|
func (d *Dao) replaceMemberInReply(r *model.Reply, umap map[int64]*user.UserBase) { |
|
if u, ok := umap[r.Mid]; ok { |
|
r.Member.BInfo = u |
|
} else { |
|
r.Member.BInfo = new(user.UserBase) |
|
r.Member.BInfo.Mid = r.Mid |
|
r.Member.BInfo.Uname = r.Member.Name |
|
r.Member.BInfo.Face = r.Member.Avatar |
|
} |
|
for _, c := range r.Content.Members { |
|
cmid, err := strconv.ParseInt(c.Mid, 10, 64) |
|
if err != nil { |
|
log.Errorv( |
|
context.Background(), |
|
log.KV("log", fmt.Sprintf("strconv err [%v] data[%s]", err, c.Mid)), |
|
) |
|
continue |
|
} |
|
if u, ok := umap[cmid]; ok { |
|
c.BInfo = u |
|
} else { |
|
c.BInfo = new(user.UserBase) |
|
c.BInfo.Mid = cmid |
|
c.BInfo.Uname = c.Name |
|
c.BInfo.Face = c.Avatar |
|
} |
|
} |
|
if len(r.Replies) > 0 { |
|
d.replaceMemberInReplys(r.Replies, umap) |
|
} |
|
} |
|
|
|
// ReplyAdd http请求添加评论 |
|
func (d *Dao) ReplyAdd(c context.Context, req map[string]interface{}) (res *model.AddRes, err error) { |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
res = new(model.AddRes) |
|
var r []byte |
|
r, err = replyHTTPCommon(c, d.httpClient, d.c.URLs["reply_add"], "POST", req, ip) |
|
if err != nil { |
|
log.Infov(c, |
|
log.KV("log", fmt.Sprintf("replyHTTPCommon err [%v]", err)), |
|
) |
|
} |
|
var json = jsoniter.ConfigCompatibleWithStandardLibrary |
|
json.Unmarshal(r, &res) |
|
return |
|
} |
|
|
|
//ReplyLike http请求评论点赞 |
|
func (d *Dao) ReplyLike(c context.Context, req map[string]interface{}) (err error) { |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
_, err = replyHTTPCommon(c, d.httpClient, d.c.URLs["reply_like"], "POST", req, ip) |
|
return |
|
} |
|
|
|
// ReplyList 评论列表 |
|
func (d *Dao) ReplyList(c context.Context, req map[string]interface{}) (res *model.ReplyList, err error) { |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
res = new(model.ReplyList) |
|
var r []byte |
|
r, err = replyHTTPCommon(c, d.httpClient, d.c.URLs["reply_list"], "GET", req, ip) |
|
if err != nil { |
|
log.Infov(c, |
|
log.KV("log", fmt.Sprintf("replyHTTPCommon err [%v]", err)), |
|
) |
|
return |
|
} |
|
var json = jsoniter.ConfigCompatibleWithStandardLibrary |
|
decoder := json.NewDecoder(bytes.NewBuffer(r)) |
|
decoder.UseNumber() |
|
err = decoder.Decode(&res) |
|
if err != nil { |
|
log.Errorv(c, log.KV("log", fmt.Sprintf("json unmarlshal err data[%s]", string(r)))) |
|
return |
|
} |
|
//获取所有mid |
|
var mid []int64 |
|
if res.Replies != nil { |
|
mid = append(mid, d.getMidInReplys(res.Replies)...) |
|
} |
|
if res.Hots != nil { |
|
mid = append(mid, d.getMidInReplys(res.Hots)...) |
|
} |
|
if res.Top != nil { |
|
mid = append(mid, res.Top.Mid) |
|
} |
|
//批量获取userinfo |
|
var userinfo map[int64]*user.UserBase |
|
userinfo, err = d.JustGetUserBase(c, mid) |
|
if err != nil { |
|
log.Errorv(c, log.KV("log", fmt.Sprintf("d.UserBase err[%v]", err))) |
|
return |
|
} |
|
if res.Replies != nil { |
|
d.replaceMemberInReplys(res.Replies, userinfo) |
|
} |
|
if res.Hots != nil { |
|
d.replaceMemberInReplys(res.Hots, userinfo) |
|
} |
|
if res.Top != nil { |
|
d.replaceMemberInReplys(res.Top.Replies, userinfo) |
|
} |
|
return |
|
} |
|
|
|
// ReplyReport 评论举报 |
|
func (d *Dao) ReplyReport(c context.Context, req map[string]interface{}) (err error) { |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
_, err = replyHTTPCommon(c, d.httpClient, d.c.URLs["reply_report"], "POST", req, ip) |
|
return |
|
} |
|
|
|
// ReplyCounts 批量评论数 |
|
func (d *Dao) ReplyCounts(c context.Context, ids []int64, t int64) (res map[int64]*model.ReplyCount, err error) { |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
oidStr := strings.Replace(strings.Trim(fmt.Sprint(ids), "[]"), " ", ",", -1) |
|
req := map[string]interface{}{ |
|
"type": t, |
|
"oid": oidStr, |
|
} |
|
res = make(map[int64]*model.ReplyCount) |
|
var r []byte |
|
r, err = replyHTTPCommon(c, d.httpClient, d.c.URLs["reply_counts"], "GET", req, ip) |
|
if err != nil { |
|
log.Infov(c, |
|
log.KV("log", fmt.Sprintf("replyHTTPCommon err [%v]", err)), |
|
) |
|
return |
|
} |
|
var json = jsoniter.ConfigCompatibleWithStandardLibrary |
|
decoder := json.NewDecoder(bytes.NewBuffer(r)) |
|
decoder.UseNumber() |
|
err = decoder.Decode(&res) |
|
if err != nil { |
|
log.Errorv(c, log.KV("log", fmt.Sprintf("json unmarlshal err data[%s]", string(r)))) |
|
} |
|
return |
|
} |
|
|
|
// ReplyMinfo 批量请求评论 |
|
func (d *Dao) ReplyMinfo(c context.Context, svID int64, rpids []int64) (res map[int64]*model.Reply, err error) { |
|
res = make(map[int64]*model.Reply) |
|
if len(rpids) == 0 { |
|
return |
|
} |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
var rpidStr string |
|
for _, rpid := range rpids { |
|
if len(rpidStr) != 0 { |
|
rpidStr += fmt.Sprintf(",%d", rpid) |
|
} else { |
|
rpidStr += fmt.Sprintf("%d", rpid) |
|
} |
|
|
|
} |
|
log.V(1).Infov(c, log.KV("log", "reply minfo: rpids="+rpidStr)) |
|
|
|
req := map[string]interface{}{ |
|
"type": model.DefaultCmType, |
|
"oid": svID, |
|
"rpid": rpidStr, |
|
} |
|
var r []byte |
|
r, err = replyHTTPCommon(c, d.httpClient, d.c.URLs["reply_minfo"], "GET", req, ip) |
|
if err != nil { |
|
log.Errorv(c, |
|
log.KV("log", fmt.Sprintf("replyHTTPCommon err [%v]", err)), |
|
) |
|
return |
|
} |
|
|
|
var json = jsoniter.ConfigCompatibleWithStandardLibrary |
|
decoder := json.NewDecoder(bytes.NewBuffer(r)) |
|
decoder.UseNumber() |
|
err = decoder.Decode(&res) |
|
if err != nil { |
|
log.Errorv(c, log.KV("log", fmt.Sprintf("json unmarlshal err data[%s]", string(r)))) |
|
} |
|
log.V(1).Infov(c, log.KV("log", "get reply minfo"), log.KV("req_size", len(rpids)), log.KV("rsp_size", len(res))) |
|
return |
|
|
|
} |
|
|
|
// ReplyHot 获取批量热评 |
|
func (d *Dao) ReplyHot(c context.Context, mid int64, oids []int64) (res map[int64][]*model.Reply, err error) { |
|
res = make(map[int64][]*model.Reply) |
|
if len(oids) == 0 { |
|
return |
|
} |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
var oidStr string |
|
for _, oid := range oids { |
|
if len(oidStr) != 0 { |
|
oidStr += fmt.Sprintf(",%d", oid) |
|
} else { |
|
oidStr += fmt.Sprintf("%d", oid) |
|
} |
|
|
|
} |
|
log.V(1).Infov(c, log.KV("log", "reply minfo: oids="+oidStr)) |
|
|
|
req := map[string]interface{}{ |
|
"type": model.DefaultCmType, |
|
"oids": oidStr, |
|
"mid": mid, |
|
} |
|
var r []byte |
|
r, err = replyHTTPCommon(c, d.httpClient, d.c.URLs["reply_hots"], "GET", req, ip) |
|
if err != nil { |
|
log.Errorv(c, |
|
log.KV("log", fmt.Sprintf("replyHTTPCommon err [%v]", err)), |
|
) |
|
return |
|
} |
|
|
|
var json = jsoniter.ConfigCompatibleWithStandardLibrary |
|
decoder := json.NewDecoder(bytes.NewBuffer(r)) |
|
decoder.UseNumber() |
|
err = decoder.Decode(&res) |
|
if err != nil { |
|
log.Errorv(c, log.KV("log", fmt.Sprintf("json unmarlshal err data[%s]", string(r)))) |
|
} |
|
log.V(1).Infov(c, log.KV("log", "get reply hots"), log.KV("req_size", len(oids)), log.KV("rsp_size", len(res))) |
|
|
|
// 替换bbq的用户信息 |
|
var mIDs []int64 |
|
for _, replies := range res { |
|
for _, reply := range replies { |
|
mIDs = append(mIDs, reply.Mid) |
|
} |
|
} |
|
var userBases map[int64]*user.UserBase |
|
userBases, err = d.JustGetUserBase(c, mIDs) |
|
if err != nil { |
|
log.Errorv(c, log.KV("log", fmt.Sprintf("d.UserBase err[%v]", err))) |
|
return |
|
} |
|
for _, replies := range res { |
|
if len(replies) > 0 { |
|
d.replaceMemberInReplys(replies, userBases) |
|
} |
|
} |
|
|
|
return |
|
|
|
}
|
|
|