293 lines
7.7 KiB
Go
293 lines
7.7 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"go-common/app/interface/bbq/app-bbq/api/http/v1"
|
|
"go-common/app/interface/bbq/app-bbq/dao"
|
|
"go-common/app/interface/bbq/app-bbq/model"
|
|
notice "go-common/app/service/bbq/notice-service/api/v1"
|
|
"go-common/library/ecode"
|
|
"go-common/library/log"
|
|
bm "go-common/library/net/http/blademaster"
|
|
"net/url"
|
|
"strconv"
|
|
)
|
|
|
|
//CommentSubCursor 游标评论列表
|
|
func (s *Service) CommentSubCursor(c context.Context, mid int64, arg *v1.CommentSubCursorReq, device *bm.Device) (res *model.SubCursorRes, err error) {
|
|
res = new(model.SubCursorRes)
|
|
if _, err = s.dao.VideoBase(c, mid, arg.SvID); err != nil {
|
|
log.Warnw(c, "log", "get video base fail", "svid", arg.SvID)
|
|
return
|
|
}
|
|
|
|
req := map[string]interface{}{
|
|
"oid": arg.SvID,
|
|
"type": arg.Type,
|
|
"sort": arg.Sort,
|
|
"root": arg.Root,
|
|
}
|
|
if len(arg.Access) != 0 {
|
|
req["access_key"] = arg.Access
|
|
}
|
|
if arg.RpID != 0 {
|
|
req["rpid"] = arg.RpID
|
|
}
|
|
if arg.Size != 0 {
|
|
req["size"] = arg.Size
|
|
}
|
|
if arg.MinID > 0 && arg.MaxID > 0 {
|
|
err = ecode.ParamInvalid
|
|
return
|
|
}
|
|
if arg.MinID != 0 {
|
|
req["min_id"] = arg.MinID
|
|
}
|
|
if arg.MaxID != 0 {
|
|
req["max_id"] = arg.MaxID
|
|
}
|
|
|
|
res, err = s.dao.ReplySubCursor(c, req)
|
|
return
|
|
}
|
|
|
|
//CommentList 游标评论列表
|
|
func (s *Service) CommentList(c context.Context, arg *v1.CommentListReq, device *bm.Device) (res *model.ReplyList, err error) {
|
|
res = new(model.ReplyList)
|
|
if _, err = s.dao.VideoBase(c, arg.MID, arg.SvID); err != nil {
|
|
log.Warnw(c, "log", "get video base fail", "svid", arg.SvID)
|
|
return
|
|
}
|
|
|
|
req := map[string]interface{}{
|
|
"oid": arg.SvID,
|
|
"type": arg.Type,
|
|
"sort": arg.Sort,
|
|
"nohot": arg.NoHot,
|
|
}
|
|
|
|
if len(arg.Access) != 0 {
|
|
req["access_key"] = arg.Access
|
|
}
|
|
if arg.Pn != 0 {
|
|
req["pn"] = arg.Pn
|
|
}
|
|
if arg.Ps != 0 {
|
|
req["ps"] = arg.Ps
|
|
}
|
|
if device.Build != 0 {
|
|
req["build"] = arg.Build
|
|
}
|
|
if device.RawPlatform != "" {
|
|
req["plat"] = arg.Plat
|
|
}
|
|
if device.RawMobiApp != "" {
|
|
req["mobi_app"] = device.RawMobiApp
|
|
}
|
|
res, err = s.dao.ReplyList(c, req)
|
|
return
|
|
}
|
|
|
|
//CommentCursor 游标评论列表
|
|
func (s *Service) CommentCursor(c context.Context, arg *v1.CommentCursorReq, device *bm.Device) (res *model.CursorRes, err error) {
|
|
res = new(model.CursorRes)
|
|
if _, err = s.dao.VideoBase(c, arg.MID, arg.SvID); err != nil {
|
|
log.Warnw(c, "log", "get video base fail", "svid", arg.SvID)
|
|
return
|
|
}
|
|
|
|
req := map[string]interface{}{
|
|
"oid": arg.SvID,
|
|
"type": arg.Type,
|
|
"sort": arg.Sort,
|
|
"max_id": arg.MaxID,
|
|
"min_id": arg.MinID,
|
|
"size": arg.Size,
|
|
}
|
|
if arg.RpID != 0 {
|
|
req["rpid"] = arg.RpID
|
|
}
|
|
if len(arg.Access) != 0 {
|
|
req["access_key"] = arg.Access
|
|
}
|
|
res, err = s.dao.ReplyCursor(c, req)
|
|
return
|
|
}
|
|
|
|
//CommentAdd 发表评论评论服务
|
|
func (s *Service) CommentAdd(c context.Context, mid int64, arg *v1.CommentAddReq, device *bm.Device) (res *model.AddRes, err error) {
|
|
res = new(model.AddRes)
|
|
// 屏蔽词
|
|
level, filterErr := s.dao.Filter(c, arg.Message, dao.FilterAreaReply)
|
|
if filterErr != nil {
|
|
log.Errorv(c, log.KV("log", "filter fail"))
|
|
} else if level >= dao.FilterLevel {
|
|
err = ecode.CommentFilterErr
|
|
log.Warnv(c, log.KV("log", fmt.Sprintf("content filter fail: content=%s, level=%d", arg.Message, level)))
|
|
return
|
|
}
|
|
|
|
var upMid int64
|
|
videoBase, err := s.dao.VideoBase(c, mid, arg.SvID)
|
|
if err != nil {
|
|
log.Warnw(c, "log", "get video base fail", "svid", arg.SvID)
|
|
return
|
|
}
|
|
upMid = videoBase.Mid
|
|
parentMid := upMid
|
|
|
|
req := map[string]interface{}{
|
|
"oid": arg.SvID,
|
|
"type": arg.Type,
|
|
"message": arg.Message,
|
|
"access_key": arg.AccessKey,
|
|
}
|
|
if arg.At != "" {
|
|
req["at"] = arg.At
|
|
}
|
|
if arg.Parent != 0 {
|
|
req["parent"] = arg.Parent
|
|
req["root"] = arg.Root
|
|
} else if arg.Root != 0 {
|
|
req["root"] = arg.Root
|
|
}
|
|
if arg.Plat != 0 {
|
|
req["plat"] = arg.Plat
|
|
}
|
|
if arg.Device != "" {
|
|
req["device"] = arg.Plat
|
|
}
|
|
if arg.Code != "" {
|
|
req["code"] = arg.Code
|
|
}
|
|
res, err = s.dao.ReplyAdd(c, req)
|
|
//wrap error
|
|
switch ecode.Cause(err).Code() {
|
|
case ecode.ReplyDeniedAsCaptcha.Code():
|
|
err = ecode.CommentForbidden
|
|
case ecode.ReplyContentOver.Code():
|
|
err = ecode.CommentLengthIllegal
|
|
}
|
|
// 推送评论给通知中心
|
|
if err == nil {
|
|
title := "评论了你的作品"
|
|
bizType := int32(notice.NoticeBizTypeSv)
|
|
rootID := res.RpID
|
|
if arg.Parent != 0 {
|
|
title = "回复了你的评论"
|
|
bizType = int32(notice.NoticeBizTypeComment)
|
|
rootID = arg.Parent
|
|
// get root comment's owner
|
|
list, tmpErr := s.dao.ReplyMinfo(c, arg.SvID, []int64{arg.Parent})
|
|
if tmpErr != nil || len(list) == 0 {
|
|
log.Warnv(c, log.KV("log", "get root reply rpid info fail"), log.KV("rsp_size", len(list)))
|
|
return
|
|
}
|
|
reply, exists := list[arg.Parent]
|
|
if !exists {
|
|
log.Errorv(c, log.KV("log", "not found reply rpid's info"))
|
|
return
|
|
} else if reply.Mid == 0 {
|
|
log.Errorv(c, log.KV("log", "reply rpid's owner mid=0"))
|
|
return
|
|
}
|
|
parentMid = reply.Mid
|
|
}
|
|
if parentMid == mid {
|
|
log.V(1).Infov(c, log.KV("log", "action_mid=mid"), log.KV("mid", mid))
|
|
return
|
|
}
|
|
urlVal := make(url.Values)
|
|
urlVal.Add("svid", strconv.FormatInt(arg.SvID, 10))
|
|
urlVal.Add("rootid", strconv.FormatInt(rootID, 10))
|
|
urlVal.Add("rpid", strconv.FormatInt(res.RpID, 10))
|
|
jumpURL := fmt.Sprintf("qing://commentdetail?%s", urlVal.Encode())
|
|
notice := ¬ice.NoticeBase{
|
|
Mid: parentMid, ActionMid: mid, SvId: arg.SvID, NoticeType: notice.NoticeTypeComment, Title: title, Text: arg.Message,
|
|
JumpUrl: jumpURL, BizType: bizType, BizId: res.RpID}
|
|
tmpErr := s.dao.CreateNotice(c, notice)
|
|
if tmpErr != nil {
|
|
log.Error("create comment notice fail: notice_msg=%s", notice.String())
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
//CommentLike 评论点赞服务
|
|
func (s *Service) CommentLike(c context.Context, mid int64, arg *v1.CommentLikeReq, device *bm.Device) (err error) {
|
|
if _, err = s.dao.VideoBase(c, mid, arg.SvID); err != nil {
|
|
log.Warnw(c, "log", "get video base fail", "svid", arg.SvID)
|
|
return
|
|
}
|
|
|
|
req := map[string]interface{}{
|
|
"oid": arg.SvID,
|
|
"type": arg.Type,
|
|
"rpid": arg.RpID,
|
|
"action": arg.Action,
|
|
"access_key": arg.AccessKey,
|
|
}
|
|
err = s.dao.ReplyLike(c, req)
|
|
if ecode.Cause(err).Code() == ecode.ReplyForbidAction.Code() {
|
|
err = ecode.CommentForbidLike
|
|
return
|
|
}
|
|
// TODO: 推送评论给通知中心
|
|
if arg.Action == 1 && err == nil {
|
|
// get root comment's owner
|
|
list, tmpErr := s.dao.ReplyMinfo(c, arg.SvID, []int64{arg.RpID})
|
|
if tmpErr != nil || len(list) == 0 {
|
|
log.Warnv(c, log.KV("log", "get root rpid info fail"))
|
|
return
|
|
}
|
|
reply, exists := list[arg.RpID]
|
|
if !exists {
|
|
log.Errorv(c, log.KV("log", "not found reply rpid's info"))
|
|
return
|
|
} else if reply.Mid == 0 {
|
|
log.Errorv(c, log.KV("log", "reply rpid's owner mid=0"))
|
|
return
|
|
}
|
|
parentMid := reply.Mid
|
|
if parentMid == mid {
|
|
log.V(1).Infov(c, log.KV("log", "action_mid=mid"), log.KV("mid", mid))
|
|
return
|
|
}
|
|
|
|
text := ""
|
|
if reply.Content != nil {
|
|
text = reply.Content.Message
|
|
}
|
|
title := "点赞了你的评论"
|
|
bizType := int32(notice.NoticeBizTypeComment)
|
|
notice := ¬ice.NoticeBase{
|
|
Mid: parentMid, ActionMid: mid, SvId: arg.SvID, NoticeType: notice.NoticeTypeLike, Title: title, Text: text,
|
|
BizType: bizType, BizId: arg.RpID}
|
|
tmpErr = s.dao.CreateNotice(c, notice)
|
|
if tmpErr != nil {
|
|
log.Errorv(c, log.KV("log", "create like notice fail: notice_msg="+notice.String()+", err="+err.Error()))
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
//CommentReport 评论举报服务
|
|
func (s *Service) CommentReport(c context.Context, arg *v1.CommentReportReq) (err error) {
|
|
req := map[string]interface{}{
|
|
"oid": arg.SvID,
|
|
"type": arg.Type,
|
|
"rpid": arg.RpID,
|
|
"reason": arg.Reason,
|
|
"access_key": arg.AccessKey,
|
|
}
|
|
if arg.Content != "" {
|
|
req["content"] = arg.Content
|
|
}
|
|
err = s.dao.ReplyReport(c, req)
|
|
return
|
|
}
|