1451 lines
36 KiB
Go
1451 lines
36 KiB
Go
package http
|
||
|
||
import (
|
||
"net/url"
|
||
"regexp"
|
||
"strconv"
|
||
"strings"
|
||
|
||
"go-common/app/interface/main/reply/conf"
|
||
"go-common/app/interface/main/reply/model/adminlog"
|
||
model "go-common/app/interface/main/reply/model/reply"
|
||
xmodel "go-common/app/interface/main/reply/model/xreply"
|
||
"go-common/app/interface/main/reply/service"
|
||
"go-common/library/ecode"
|
||
"go-common/library/log"
|
||
bm "go-common/library/net/http/blademaster"
|
||
"go-common/library/xstr"
|
||
)
|
||
|
||
// regexp utf8 char 0x0e0d~0e4A
|
||
var (
|
||
_emptyUnicodeReg = []*regexp.Regexp{
|
||
regexp.MustCompile(`[\x{202e}]+`), // right-to-left override
|
||
regexp.MustCompile(`[\x{200b}]+`), // zeroWithChar
|
||
regexp.MustCompile(`[\x{1f6ab}]+`), // no_entry_sign
|
||
}
|
||
re = regexp.MustCompile(`[\x{0E0D}\x{0E4A}]+`)
|
||
_emojis = regexp.MustCompile(`\[[^\[+][^]]+]`)
|
||
// trim
|
||
returnReg = regexp.MustCompile(`[\n]{3,}`)
|
||
returnReg2 = regexp.MustCompile(`(\r\n){3,}`)
|
||
spaceReg = regexp.MustCompile(`[ ]{5,}`) // Chinese quanjiao space character
|
||
)
|
||
|
||
func isMobile(params url.Values) bool {
|
||
//return (params.Get("appkey") == "c1b107428d337928" || params.Get("appkey") == "27eb53fc9058f8c3") && len(params.Get("access_key")) == 32
|
||
return params.Get("mobi_app") != ""
|
||
}
|
||
|
||
// replyInfo get reply info by rpID.
|
||
func replyInfo(c *bm.Context) {
|
||
params := c.Request.Form
|
||
oidStr := params.Get("oid")
|
||
tpStr := params.Get("type")
|
||
rpStr := params.Get("rpid")
|
||
// check params
|
||
oid, err := strconv.ParseInt(oidStr, 10, 64)
|
||
if err != nil || oid <= 0 {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", oidStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
rpID, err := strconv.ParseInt(rpStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", rpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
rp, err := rpSvr.Reply(c, oid, int8(tp), rpID)
|
||
if err != nil {
|
||
log.Warn("rpSvr.Reply(%d, %d, %d) error(%s)", oid, tp, rpID, err)
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
c.JSON(rp, nil)
|
||
}
|
||
|
||
func replyMultiInfo(c *bm.Context) {
|
||
params := c.Request.Form
|
||
oidStr := params.Get("oid")
|
||
tpStr := params.Get("type")
|
||
rpStr := params.Get("rpid")
|
||
// check params
|
||
oids, err := xstr.SplitInts(oidStr)
|
||
if err != nil {
|
||
log.Warn("xstr.SplitInts(%s) err(%v)", err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
rpIDs, err := xstr.SplitInts(rpStr)
|
||
if err != nil {
|
||
log.Warn("xstr.SplintInt(%s) err(%v)", rpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if len(oids) != len(rpIDs) {
|
||
log.Warn("miss oid:%v rpid:%v", oidStr, rpStr)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
data := map[string]*model.Reply{}
|
||
for i := 0; i < len(oids); i++ {
|
||
rp, err := rpSvr.Reply(c, oids[i], int8(tp), rpIDs[i])
|
||
if err != nil {
|
||
log.Warn("rpSvr.Reply(%d, %d, %d) error(%s)", oids[i], tp, rpIDs[i], err)
|
||
continue
|
||
}
|
||
data[strconv.FormatInt(rpIDs[i], 10)] = rp
|
||
}
|
||
c.JSON(data, nil)
|
||
}
|
||
|
||
// reply range subject replies.
|
||
func reply(c *bm.Context) {
|
||
var (
|
||
showEntry = int(1)
|
||
showAdmin = int(1)
|
||
showFloor = int(1)
|
||
mid int64
|
||
sort int64
|
||
build int64
|
||
plat int64
|
||
oid int64
|
||
curPage int
|
||
err error
|
||
nohot bool
|
||
)
|
||
params := c.Request.Form
|
||
oidStr := params.Get("oid")
|
||
otypStr := params.Get("type")
|
||
sortStr := params.Get("sort")
|
||
curPageStr := params.Get("pn")
|
||
perPageStr := params.Get("ps")
|
||
nohotStr := params.Get("nohot")
|
||
platStr := params.Get("plat")
|
||
buildStr := params.Get("build")
|
||
appStr := params.Get("mobi_app")
|
||
buvid := c.Request.Header.Get("buvid")
|
||
if m, ok := c.Get("mid"); ok {
|
||
mid = m.(int64)
|
||
}
|
||
if platStr == "" {
|
||
plat = int64(model.PlatWeb)
|
||
} else {
|
||
plat, err = strconv.ParseInt(platStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(platStr %s) err(%v)", platStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
if buildStr != "" {
|
||
build, err = strconv.ParseInt(buildStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(build %s) err(%v)", buildStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
oid, err = strconv.ParseInt(oidStr, 10, 64)
|
||
if err != nil || oid <= 0 {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", oidStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
otyp, err := strconv.ParseInt(otypStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", otypStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if sortStr != "" {
|
||
sort, err = strconv.ParseInt(sortStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", sortStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
curPage, err = strconv.Atoi(curPageStr)
|
||
if err != nil || curPage < 1 {
|
||
curPage = 1
|
||
}
|
||
perPage, err := strconv.Atoi(perPageStr)
|
||
if err != nil || perPage > conf.Conf.Reply.MaxPageSize || perPage <= 0 {
|
||
perPage = conf.Conf.Reply.MaxPageSize
|
||
}
|
||
htmlEscape := true
|
||
needSndReply := true
|
||
// check android and ios appkey
|
||
if appStr != "" {
|
||
// if mobile, no html escape
|
||
htmlEscape = false
|
||
// if mobile, no return second replies of hot and top reply
|
||
if int8(sort) == model.SortByFloor {
|
||
needSndReply = false
|
||
}
|
||
}
|
||
if nohotStr != "" {
|
||
nohot, _ = strconv.ParseBool(nohotStr)
|
||
}
|
||
pageParams := &model.PageParams{
|
||
Mid: mid,
|
||
Oid: oid,
|
||
Type: int8(otyp),
|
||
Sort: int8(sort),
|
||
PageNum: curPage,
|
||
PageSize: perPage,
|
||
NeedSecond: needSndReply,
|
||
Escape: htmlEscape,
|
||
NeedHot: !nohot,
|
||
}
|
||
pageRes, err := rpSvr.RootReplies(c, pageParams)
|
||
if err != nil {
|
||
log.Warn("rpSvr.RootReplies(%+v) error(%v)", pageParams, err)
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if config, _ := rpSvr.GetReplyLogConfig(c, pageRes.Subject, 1); config != nil {
|
||
showEntry = int(config.ShowEntry)
|
||
showAdmin = int(config.ShowAdmin)
|
||
}
|
||
if !rpSvr.ShowFloor(pageParams.Oid, pageParams.Type) {
|
||
showFloor = int(0)
|
||
if !isMobile(params) {
|
||
rpSvr.ResetFloor(pageRes.Roots...)
|
||
rpSvr.ResetFloor(pageRes.TopAdmin)
|
||
rpSvr.ResetFloor(pageRes.TopUpper)
|
||
rpSvr.ResetFloor(pageRes.Hots...)
|
||
}
|
||
}
|
||
rpSvr.EmojiReplace(int8(plat), build, pageRes.Roots...)
|
||
rpSvr.EmojiReplace(int8(plat), build, pageRes.TopAdmin)
|
||
rpSvr.EmojiReplace(int8(plat), build, pageRes.TopUpper)
|
||
rpSvr.EmojiReplace(int8(plat), build, pageRes.Hots...)
|
||
rpSvr.EmojiReplaceI(appStr, build, pageRes.Roots...)
|
||
rpSvr.EmojiReplaceI(appStr, build, pageRes.TopAdmin)
|
||
rpSvr.EmojiReplaceI(appStr, build, pageRes.TopUpper)
|
||
rpSvr.EmojiReplaceI(appStr, build, pageRes.Hots...)
|
||
pageRes.Roots = rpSvr.FilDelReply(pageRes.Roots)
|
||
pageRes.Hots = rpSvr.FilDelReply(pageRes.Hots)
|
||
data := map[string]interface{}{
|
||
"page": map[string]int{
|
||
"num": curPage,
|
||
"size": perPage,
|
||
"count": pageRes.Total,
|
||
"acount": pageRes.AllCount,
|
||
},
|
||
"config": map[string]int{
|
||
"showentry": showEntry,
|
||
"showadmin": showAdmin,
|
||
"showfloor": showFloor,
|
||
},
|
||
"replies": pageRes.Roots,
|
||
"hots": pageRes.Hots,
|
||
"upper": map[string]interface{}{
|
||
"mid": pageRes.Subject.Mid,
|
||
"top": pageRes.TopUpper,
|
||
},
|
||
"top": pageRes.TopAdmin,
|
||
"notice": rpSvr.RplyNotice(c, int8(plat), build, appStr, buvid),
|
||
}
|
||
if mid > 0 {
|
||
if !(rpSvr.IsWhiteAid(oid, int8(otyp))) {
|
||
if rpSvr.RelationBlocked(c, pageRes.Subject.Mid, mid) {
|
||
data["blacklist"] = 1
|
||
}
|
||
if ok, _ := rpSvr.CheckAssist(c, pageRes.Subject.Mid, mid); ok {
|
||
data["assist"] = 1
|
||
}
|
||
}
|
||
}
|
||
c.JSON(data, nil)
|
||
}
|
||
|
||
// replyReply range replies from root reply.
|
||
func replyReply(c *bm.Context) {
|
||
var (
|
||
err error
|
||
mid int64
|
||
root int64
|
||
jumpID int64
|
||
escape = true
|
||
)
|
||
params := c.Request.Form
|
||
oidStr := params.Get("oid")
|
||
tpStr := params.Get("type")
|
||
rtStr := params.Get("root")
|
||
jumpStr := params.Get("jump")
|
||
pnStr := params.Get("pn")
|
||
psStr := params.Get("ps")
|
||
midS, ok := c.Get("mid")
|
||
if !ok {
|
||
log.Warn("user no login")
|
||
mid = 0
|
||
} else {
|
||
mid = midS.(int64)
|
||
}
|
||
// check params
|
||
oid, err := strconv.ParseInt(oidStr, 10, 64)
|
||
if err != nil || oid <= 0 {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", oidStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
pn, err := strconv.Atoi(pnStr)
|
||
if err != nil || pn < 1 {
|
||
pn = 1
|
||
}
|
||
ps, err := strconv.Atoi(psStr)
|
||
if err != nil || ps > conf.Conf.Reply.MaxPageSize || ps <= 0 {
|
||
ps = conf.Conf.Reply.MaxPageSize
|
||
}
|
||
if jumpStr != "" {
|
||
if jumpID, err = strconv.ParseInt(jumpStr, 10, 64); err != nil {
|
||
log.Warn("strconv.ParseInt(jump:%s) error(%v)", jumpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
} else {
|
||
if root, err = strconv.ParseInt(rtStr, 10, 64); err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", rtStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
// check android and ios appkey
|
||
if isMobile(params) {
|
||
// if mobile, no html escape
|
||
escape = false
|
||
}
|
||
var config xmodel.ReplyConfig
|
||
config.ShowFloor = 1
|
||
if !rpSvr.ShowFloor(oid, int8(tp)) {
|
||
config.ShowFloor = 0
|
||
}
|
||
rs, rtRp, umid, pn, err := rpSvr.SecondReplies(c, mid, oid, root, jumpID, int8(tp), pn, ps, escape)
|
||
if err == nil {
|
||
if config.ShowFloor == 0 && !isMobile(params) {
|
||
rpSvr.ResetFloor(rs...)
|
||
rpSvr.ResetFloor(rtRp)
|
||
}
|
||
data := make(map[string]interface{}, 2)
|
||
data["page"] = map[string]int{
|
||
"num": pn,
|
||
"size": ps,
|
||
"count": rtRp.RCount,
|
||
}
|
||
data["upper"] = map[string]int64{
|
||
"mid": umid,
|
||
}
|
||
data["replies"] = rs
|
||
data["root"] = rtRp
|
||
data["config"] = config
|
||
if mid > 0 {
|
||
if !(rpSvr.IsWhiteAid(oid, int8(tp))) {
|
||
if rpSvr.RelationBlocked(c, rtRp.Mid, mid) {
|
||
data["blacklist"] = 1
|
||
}
|
||
if ok, _ := rpSvr.CheckAssist(c, umid, mid); ok {
|
||
data["assist"] = 1
|
||
}
|
||
}
|
||
}
|
||
c.JSON(data, nil)
|
||
} else {
|
||
log.Warn("rpSvr.ReplyReplies(%d, %d, %d) error(%d)", oid, root, tp, err)
|
||
c.JSON(nil, err)
|
||
}
|
||
}
|
||
|
||
func getTopics(c *bm.Context) {
|
||
var (
|
||
err error
|
||
mid int64
|
||
)
|
||
params := c.Request.Form
|
||
midStr, ok := c.Get("mid")
|
||
if ok {
|
||
mid = midStr.(int64)
|
||
} else {
|
||
midStr := params.Get("mid")
|
||
mid, err = strconv.ParseInt(midStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", midStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
oidStr := params.Get("oid")
|
||
tpStr := params.Get("type")
|
||
msg := params.Get("message")
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if !model.LegalSubjectType(int8(tp)) {
|
||
err = ecode.ReplyIllegalSubType
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
oid, err := strconv.ParseInt(oidStr, 10, 64)
|
||
if err != nil || oid <= 0 {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", oidStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if int8(tp) == model.SubTypeDynamic || int8(tp) == model.SubTypeLivePicture || int8(tp) == model.SubTypeLive {
|
||
data := map[string]interface{}{
|
||
"topics": []string{},
|
||
}
|
||
c.JSON(data, nil)
|
||
return
|
||
}
|
||
topics, err := rpSvr.Topics(c, mid, oid, int8(tp), msg)
|
||
if err != nil {
|
||
log.Warn("rpSvr.Topics(%d,%d,%d,%s) error(%v)", mid, oid, tp, msg, err)
|
||
topics = make([]string, 0)
|
||
}
|
||
data := map[string]interface{}{
|
||
"topics": topics,
|
||
}
|
||
c.JSON(data, nil)
|
||
}
|
||
|
||
// addReply add a reply.
|
||
func addReply(c *bm.Context) {
|
||
var (
|
||
err error
|
||
rp *model.Reply
|
||
captchaURL string
|
||
ats []int64
|
||
root, parent int64
|
||
plat int64
|
||
build int64
|
||
)
|
||
params := c.Request.Form
|
||
midStr, _ := c.Get("mid")
|
||
mid := midStr.(int64)
|
||
oidStr := params.Get("oid")
|
||
tpStr := params.Get("type")
|
||
rtStr := params.Get("root")
|
||
paStr := params.Get("parent")
|
||
atStr := params.Get("at")
|
||
msg := params.Get("message")
|
||
platStr := params.Get("plat")
|
||
device := params.Get("device")
|
||
version := params.Get("version")
|
||
captcha := params.Get("code")
|
||
ak := params.Get("access_key")
|
||
platform := params.Get("platform")
|
||
buildStr := params.Get("build")
|
||
buvid := c.Request.Header.Get("buvid")
|
||
// check params
|
||
msg = strings.TrimSpace(msg)
|
||
msg = re.ReplaceAllString(msg, " ")
|
||
msg = spaceReg.ReplaceAllString(msg, " ")
|
||
msg = returnReg.ReplaceAllString(msg, "\n\n\n")
|
||
msg = returnReg2.ReplaceAllString(msg, "\n\n\n")
|
||
// checkout empty
|
||
for _, reg := range _emptyUnicodeReg {
|
||
msg = reg.ReplaceAllString(msg, "")
|
||
}
|
||
// check len
|
||
tmp := _emojis.ReplaceAllString(msg, "")
|
||
tmp = strings.TrimSpace(tmp)
|
||
ml := len([]rune(tmp))
|
||
if conf.Conf.Reply.MaxConLen < ml || ml < conf.Conf.Reply.MinConLen {
|
||
log.Warn("content(%s) length %d, max %d, min %d", msg, ml, conf.Conf.Reply.MaxConLen, conf.Conf.Reply.MinConLen)
|
||
err = ecode.ReplyContentOver
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
oid, err := strconv.ParseInt(oidStr, 10, 64)
|
||
if err != nil || oid <= 0 {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", oidStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if rtStr != "" {
|
||
root, err = strconv.ParseInt(rtStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", rtStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
if paStr != "" {
|
||
parent, err = strconv.ParseInt(paStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", paStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
if !((root == 0 && parent == 0) || (root > 0 && parent > 0)) {
|
||
log.Warn("the wrong root(%d) and parent(%d)", root, parent)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if !model.LegalSubjectType(int8(tp)) {
|
||
err = ecode.ReplyIllegalSubType
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if atStr != "" {
|
||
ats, err = xstr.SplitInts(atStr)
|
||
if err != nil {
|
||
log.Warn("utils.SplitInts(%s) error(%v)", atStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
if len(ats) > 10 {
|
||
log.Warn("too many people to be at len(%d)", len(ats))
|
||
err = ecode.ReplyTooManyAts
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if platStr != "" {
|
||
plat, err = strconv.ParseInt(platStr, 10, 8)
|
||
if err != nil || !model.CheckPlat(int8(plat)) {
|
||
log.Warn("the wrong plat(%s)", platStr)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
if device != "" && len([]rune(device)) > 30 {
|
||
log.Warn("device len(%d)", len([]rune(device)))
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if int8(tp) == model.SubTypeArchive {
|
||
for _, aid := range cnf.Reply.ForbidList {
|
||
if aid == oid {
|
||
err = ecode.ReplyForbidList
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
}
|
||
if buildStr != "" {
|
||
build, err = strconv.ParseInt(buildStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", buildStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
var status int
|
||
if status, err = rpSvr.UserBlockStatus(c, mid); err != nil {
|
||
err = ecode.ServerErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if status == service.StatusForbidden {
|
||
// "账号被封停"
|
||
err = ecode.UserDisabled
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if status == service.StatusNeedContest {
|
||
// 该账号处于封禁中，点击申请答题
|
||
err = ecode.ReplyContestNotPassed
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if root == 0 && parent == 0 {
|
||
rp, captchaURL, err = rpSvr.AddReply(c, mid, oid, int8(tp), int8(plat), ats, ak, c.Request.Header.Get("Cookie"), captcha, msg, device, version, platform, build, buvid)
|
||
} else {
|
||
rp, captchaURL, err = rpSvr.AddReplyReply(c, mid, oid, root, parent, int8(tp), int8(plat), ats, ak, c.Request.Header.Get("Cookie"), captcha, msg, device, version, platform, build, buvid)
|
||
}
|
||
if err != nil && err != ecode.ReplyMosaicByFilter {
|
||
log.Warn("rpSvr.AddReply or ReplyReply failed mid(%d) oid(%d) error(%d)", mid, oid, err)
|
||
data := map[string]interface{}{
|
||
"need_captcha": (captchaURL != ""),
|
||
"url": captchaURL,
|
||
}
|
||
c.JSON(data, err)
|
||
return
|
||
}
|
||
data := map[string]interface{}{
|
||
"rpid": rp.RpID,
|
||
"rpid_str": strconv.FormatInt(rp.RpID, 10),
|
||
"dialog": rp.Dialog,
|
||
"dialog_str": strconv.FormatInt(rp.Dialog, 10),
|
||
"root": rp.Root,
|
||
"root_str": strconv.FormatInt(rp.Root, 10),
|
||
"parent": rp.Parent,
|
||
"parent_str": strconv.FormatInt(rp.Parent, 10),
|
||
}
|
||
c.JSON(data, nil)
|
||
}
|
||
|
||
// likeReply do like or cancel like for reply.
|
||
func likeReply(c *bm.Context) {
|
||
params := c.Request.Form
|
||
mid, _ := c.Get("mid")
|
||
oidStr := params.Get("oid")
|
||
tpStr := params.Get("type")
|
||
rpStr := params.Get("rpid")
|
||
actStr := params.Get("action")
|
||
ak := params.Get("access_key")
|
||
platform := params.Get("platform")
|
||
buildStr := params.Get("build")
|
||
buvid := c.Request.Header.Get("buvid")
|
||
var build int64
|
||
var err error
|
||
if buildStr != "" {
|
||
build, err = strconv.ParseInt(buildStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", buildStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
// check parameters
|
||
oid, err := strconv.ParseInt(oidStr, 10, 64)
|
||
if err != nil || oid <= 0 {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", oidStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
rpID, err := strconv.ParseInt(rpStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", rpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
act, err := strconv.ParseInt(actStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", actStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
err = rpSvr.AddAction(c, mid.(int64), oid, rpID, int8(tp), int8(act), ak, c.Request.Header.Get("Cookie"), "like", platform, buvid, build)
|
||
c.JSON(nil, err)
|
||
}
|
||
|
||
// hateReply do hate or cancel hate for reply.
|
||
func hateReply(c *bm.Context) {
|
||
params := c.Request.Form
|
||
mid, _ := c.Get("mid")
|
||
oidStr := params.Get("oid")
|
||
tpStr := params.Get("type")
|
||
rpStr := params.Get("rpid")
|
||
actStr := params.Get("action")
|
||
ak := params.Get("access_key")
|
||
platform := params.Get("platform")
|
||
buildStr := params.Get("build")
|
||
buvid := c.Request.Header.Get("buvid")
|
||
var build int64
|
||
var err error
|
||
if buildStr != "" {
|
||
build, err = strconv.ParseInt(buildStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", buildStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
// check parameters
|
||
oid, err := strconv.ParseInt(oidStr, 10, 64)
|
||
if err != nil || oid <= 0 {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", oidStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
rpID, err := strconv.ParseInt(rpStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", rpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
act, err := strconv.ParseInt(actStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", actStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
err = rpSvr.AddAction(c, mid.(int64), oid, rpID, int8(tp), int8(act), ak, c.Request.Header.Get("Cookie"), "hate", platform, buvid, build)
|
||
c.JSON(nil, err)
|
||
}
|
||
|
||
// jump to specified reply.
|
||
func jumpReply(c *bm.Context) {
|
||
var (
|
||
showEntry = int(1)
|
||
showAdmin = int(1)
|
||
mid int64
|
||
escape = true
|
||
)
|
||
params := c.Request.Form
|
||
oidStr := params.Get("oid")
|
||
tpStr := params.Get("type")
|
||
rpIDStr := params.Get("rpid")
|
||
psStr := params.Get("ps")
|
||
rppsStr := params.Get("rpps")
|
||
platStr := params.Get("plat")
|
||
buildStr := params.Get("build")
|
||
appStr := params.Get("mobi_app")
|
||
midS, ok := c.Get("mid")
|
||
buvid := c.Request.Header.Get("buvid")
|
||
if !ok {
|
||
log.Warn("user no login")
|
||
mid = 0
|
||
} else {
|
||
mid = midS.(int64)
|
||
}
|
||
// check params
|
||
plat, err := strconv.ParseInt(platStr, 10, 8)
|
||
if err != nil {
|
||
plat = 1 // default pc
|
||
}
|
||
var build int64
|
||
if buildStr != "" {
|
||
build, err = strconv.ParseInt(buildStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(build %s) err(%v)", buildStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
oid, err := strconv.ParseInt(oidStr, 10, 64)
|
||
if err != nil || oid <= 0 {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", oidStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
rpID, err := strconv.ParseInt(rpIDStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", rpIDStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
ps, _ := strconv.Atoi(psStr)
|
||
if ps > conf.Conf.Reply.MaxPageSize || ps <= 0 {
|
||
ps = conf.Conf.Reply.MaxPageSize
|
||
}
|
||
rpPs, _ := strconv.Atoi(rppsStr)
|
||
if rpPs <= 0 || rpPs > conf.Conf.Reply.MaxPageSize {
|
||
rpPs = 10
|
||
}
|
||
// check android and ios appkey
|
||
if isMobile(params) {
|
||
// if mobile, no html escape
|
||
escape = false
|
||
}
|
||
rs, hots, topAdmin, topUpper, sub, pn, rtpn, total, err := rpSvr.JumpReplies(c, mid, oid, rpID, int8(tp), ps, rpPs, escape)
|
||
if err != nil && err != ecode.ReplyNotExist {
|
||
log.Warn("rpSvr.JumpReplies(%d,%d,%d,%d) error(%d)", oid, tp, rpID, ps, err)
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if err == ecode.ReplyNotExist {
|
||
var pageRes *model.PageResult
|
||
pn = 1
|
||
pageParams := &model.PageParams{
|
||
Mid: mid, Oid: oid, Type: int8(tp), Sort: model.SortByFloor, PageNum: pn, PageSize: ps, NeedHot: false, NeedSecond: false, Escape: escape,
|
||
}
|
||
if pageRes, err = rpSvr.RootReplies(c, pageParams); err != nil {
|
||
log.Warn("rpSvr.RootReplies(%d,%d,%d,%d) error(%d)", oid, tp, rpID, ps, err)
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
rs = pageRes.Roots
|
||
sub = pageRes.Subject
|
||
hots = pageRes.Hots
|
||
topAdmin = pageRes.TopAdmin
|
||
topUpper = pageRes.TopUpper
|
||
total = pageRes.Total
|
||
}
|
||
if config, _ := rpSvr.GetReplyLogConfig(c, sub, 1); config != nil {
|
||
showEntry = int(config.ShowEntry)
|
||
showAdmin = int(config.ShowAdmin)
|
||
}
|
||
rpSvr.EmojiReplace(int8(plat), build, hots...)
|
||
rpSvr.EmojiReplace(int8(plat), build, rs...)
|
||
rpSvr.EmojiReplace(int8(plat), build, topAdmin)
|
||
rpSvr.EmojiReplace(int8(plat), build, topUpper)
|
||
rpSvr.EmojiReplaceI(appStr, build, hots...)
|
||
rpSvr.EmojiReplaceI(appStr, build, rs...)
|
||
rpSvr.EmojiReplaceI(appStr, build, topAdmin)
|
||
rpSvr.EmojiReplaceI(appStr, build, topUpper)
|
||
data := make(map[string]interface{}, 2)
|
||
page := map[string]int{
|
||
"num": pn,
|
||
"size": ps,
|
||
"count": total,
|
||
"acount": sub.ACount,
|
||
"rt_num": rtpn,
|
||
}
|
||
configValue := map[string]int{
|
||
"showentry": showEntry,
|
||
"showadmin": showAdmin,
|
||
}
|
||
upper := map[string]interface{}{
|
||
"mid": sub.Mid,
|
||
"top": topUpper,
|
||
}
|
||
data["config"] = configValue
|
||
data["upper"] = upper
|
||
data["page"] = page
|
||
data["replies"] = rs
|
||
data["hots"] = hots
|
||
data["top"] = topAdmin
|
||
if notice := rpSvr.RplyNotice(c, int8(plat), build, appStr, buvid); notice != nil {
|
||
data["notice"] = notice
|
||
}
|
||
//NOTE donot need
|
||
// data["need_captcha"] = rpSvr.NeedCaptcha(c, mid)
|
||
c.JSON(data, nil)
|
||
}
|
||
|
||
// showReply show reply by upper.
|
||
func showReply(c *bm.Context) {
|
||
params := c.Request.Form
|
||
mid, _ := c.Get("mid")
|
||
oidsStr := params.Get("oid")
|
||
rpsStr := params.Get("rpid")
|
||
tpStr := params.Get("type")
|
||
ak := params.Get("access_key")
|
||
// check params
|
||
oids, err := xstr.SplitInts(oidsStr)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", oidsStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
rpIDs, err := xstr.SplitInts(rpsStr)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", rpsStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if len(oids) != len(rpIDs) {
|
||
log.Warn("oids(%v) not equal roids(%v)", oids, rpIDs)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if len(oids) != len(rpIDs) {
|
||
log.Warn("miss oid:%s rpid:%s", oidsStr, rpsStr)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
for i := 0; i < len(oids); i++ {
|
||
if oids[i] <= 0 {
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if err = rpSvr.Show(c, oids[i], mid.(int64), rpIDs[i], int8(tp), ak, c.Request.Header.Get("Cookie")); err != nil {
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
c.JSON(nil, nil)
|
||
}
|
||
|
||
// hideReplys hide reply by upper.
|
||
func hideReply(c *bm.Context) {
|
||
params := c.Request.Form
|
||
mid, _ := c.Get("mid")
|
||
oidsStr := params.Get("oid")
|
||
rpsStr := params.Get("rpid")
|
||
tpStr := params.Get("type")
|
||
ak := params.Get("access_key")
|
||
// check params
|
||
oids, err := xstr.SplitInts(oidsStr)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", oidsStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
rpIDs, err := xstr.SplitInts(rpsStr)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", rpsStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if len(oids) != len(rpIDs) {
|
||
log.Warn("oids(%v) not equal roids(%v)", oids, rpIDs)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if len(oids) != len(rpIDs) {
|
||
log.Warn("miss oid:%s rpid:%s", oidsStr, rpsStr)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
for i := 0; i < len(oids); i++ {
|
||
if oids[i] <= 0 {
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if err = rpSvr.Hide(c, oids[i], mid.(int64), rpIDs[i], int8(tp), ak, c.Request.Header.Get("Cookie")); err != nil {
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
c.JSON(nil, nil)
|
||
}
|
||
|
||
func replyCounts(c *bm.Context) {
|
||
params := c.Request.Form
|
||
oids, err := xstr.SplitInts(params.Get("oid"))
|
||
if err != nil {
|
||
log.Warn("sxtr.PlintInts(%v) err(%v)", params.Get("oid"), err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if len(oids) == 0 {
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
for i := 0; i < len(oids); i++ {
|
||
if oids[i] <= 0 {
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
otyp, err := strconv.ParseInt(params.Get("type"), 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%v) err(%v)", params.Get("type"), err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if !model.LegalSubjectType(int8(otyp)) {
|
||
err = ecode.ReplyIllegalSubType
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
counts, err := rpSvr.GetReplyCounts(c, oids, int8(otyp))
|
||
if err != nil {
|
||
log.Warn("rcSvr.GetReplyCount err(%v)", err)
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
c.JSON(counts, nil)
|
||
}
|
||
|
||
// replyCount get replies count.
|
||
func replyMultiCount(c *bm.Context) {
|
||
params := c.Request.Form
|
||
oidsStr := params.Get("oid")
|
||
tpStr := params.Get("type")
|
||
oids, err := xstr.SplitInts(oidsStr)
|
||
if err != nil {
|
||
log.Warn("sxtr.PlintInts(%v) err(%v)", oidsStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%v) err(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if len(oids) == 0 {
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
for i := 0; i < len(oids); i++ {
|
||
if oids[i] <= 0 {
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
counts, err := rpSvr.ReplyCounts(c, oids, int8(tp))
|
||
if err != nil {
|
||
log.Warn("rcSvr.ReplyCount err(%v)", err)
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
c.JSON(counts, nil)
|
||
}
|
||
|
||
// replyAdminLog fetch pages of replies deleted by upper, reply user or administrators
|
||
func replyAdminLog(c *bm.Context) {
|
||
params := c.Request.Form
|
||
oidStr := params.Get("oid")
|
||
tpStr := params.Get("type")
|
||
curPageStr := params.Get("pn")
|
||
perPageStr := params.Get("ps")
|
||
// check params
|
||
oid, err := strconv.ParseInt(oidStr, 10, 64)
|
||
if err != nil || oid <= 0 {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", oidStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
|
||
curPage, err := strconv.Atoi(curPageStr)
|
||
if err != nil || curPage < 1 {
|
||
curPage = 1
|
||
}
|
||
perPage, err := strconv.Atoi(perPageStr)
|
||
if err != nil || perPage > conf.Conf.Reply.MaxPageSize || perPage <= 0 {
|
||
perPage = conf.Conf.Reply.MaxPageSize
|
||
}
|
||
if rpSvr.IsBnj(oid, int8(tp)) {
|
||
data := map[string]interface{}{
|
||
"page": map[string]int{
|
||
"num": curPage,
|
||
"size": perPage,
|
||
"pages": 0,
|
||
"total": 0,
|
||
},
|
||
"logs": make([]*adminlog.AdminLog, 0),
|
||
"reply_count": 0,
|
||
"report_count": 0,
|
||
}
|
||
c.JSON(data, nil)
|
||
return
|
||
}
|
||
logs, replyCount, reportCount, pageCount, total, err := rpSvr.PaginateUpperDeletedLogs(c, oid, int(tp), curPage, perPage)
|
||
if err != nil {
|
||
log.Warn("rpSvr.PaginateUpperDeletedLogs(%d, %d) error(%s)", oid, tp, err)
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if replyCount > reportCount {
|
||
reportCount += replyCount
|
||
}
|
||
data := map[string]interface{}{
|
||
"page": map[string]int{
|
||
"num": curPage,
|
||
"size": perPage,
|
||
"pages": int(pageCount),
|
||
"total": int(total),
|
||
},
|
||
"logs": logs,
|
||
"reply_count": replyCount,
|
||
"report_count": reportCount,
|
||
}
|
||
c.JSON(data, nil)
|
||
}
|
||
|
||
// replyCount get replies count.
|
||
func replyCount(c *bm.Context) {
|
||
params := c.Request.Form
|
||
oidStr := params.Get("oid")
|
||
tpStr := params.Get("type")
|
||
// check params
|
||
oid, err := strconv.ParseInt(oidStr, 10, 64)
|
||
if err != nil || oid <= 0 {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", oidStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
count, err := rpSvr.ReplyCount(c, oid, int8(tp))
|
||
if err != nil {
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
data := map[string]int{"count": count}
|
||
c.JSON(data, nil)
|
||
}
|
||
|
||
// delReply delete reply by upper or self.
|
||
func delReply(c *bm.Context) {
|
||
params := c.Request.Form
|
||
mid, _ := c.Get("mid")
|
||
oidsStr := params.Get("oid")
|
||
tpStr := params.Get("type")
|
||
rpIDsStr := params.Get("rpid")
|
||
ak := params.Get("access_key")
|
||
platform := params.Get("platform")
|
||
buildStr := params.Get("build")
|
||
buvid := c.Request.Header.Get("buvid")
|
||
var build int64
|
||
var err error
|
||
// check params
|
||
if buildStr != "" {
|
||
build, err = strconv.ParseInt(buildStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(build %s) err(%v)", buildStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
oids, err := xstr.SplitInts(oidsStr)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", oidsStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
rpIDs, err := xstr.SplitInts(rpIDsStr)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", rpIDsStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if len(oids) != len(rpIDs) {
|
||
log.Warn("miss oid:%s rpid:%s", oidsStr, rpIDsStr)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
for i := 0; i < len(oids); i++ {
|
||
if oids[i] <= 0 {
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if err = rpSvr.Delete(c, mid.(int64), oids[i], rpIDs[i], int8(tp), ak, c.Request.Header.Get("Cookie"), platform, build, buvid); err != nil {
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
c.JSON(nil, nil)
|
||
}
|
||
|
||
// AddTopReply add top reply by upper
|
||
func AddTopReply(c *bm.Context) {
|
||
params := c.Request.Form
|
||
oidStr := params.Get("oid")
|
||
tpStr := params.Get("type")
|
||
rpIDStr := params.Get("rpid")
|
||
actStr := params.Get("action")
|
||
platform := params.Get("platform")
|
||
buildStr := params.Get("build")
|
||
buvid := c.Request.Header.Get("buvid")
|
||
var build int64
|
||
var err error
|
||
if buildStr != "" {
|
||
build, err = strconv.ParseInt(buildStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", buildStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
}
|
||
mid, _ := c.Get("mid")
|
||
// check params
|
||
oid, err := strconv.ParseInt(oidStr, 10, 64)
|
||
if err != nil || oid <= 0 {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", oidStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
rpID, err := strconv.ParseInt(rpIDStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", rpIDStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
tp, err := strconv.ParseInt(tpStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
act, err := strconv.ParseInt(actStr, 10, 8)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(actStr :%s) err(%v)", actStr, err)
|
||
act = 1
|
||
}
|
||
err = rpSvr.UpperAddTop(c, mid.(int64), oid, rpID, int8(tp), int8(act), platform, build, buvid)
|
||
c.JSON(nil, err)
|
||
}
|
||
|
||
// emojis
|
||
func emojis(c *bm.Context) {
|
||
params := c.Request.Form
|
||
appStr := params.Get("mobi_app")
|
||
buildStr := params.Get("build")
|
||
if buildStr != "" {
|
||
build, err := strconv.ParseInt(buildStr, 10, 64)
|
||
if err != nil {
|
||
log.Warn("strconv.ParseInt(build %s) err(%v)", buildStr, err)
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
if appStr == "android_i" && build > 1125000 && build < 2005000 {
|
||
c.JSON(nil, nil)
|
||
return
|
||
}
|
||
}
|
||
c.JSON(rpSvr.Emojis(c), nil)
|
||
}
|
||
|
||
func replyHots(c *bm.Context) {
|
||
params := c.Request.Form
|
||
oidStr := params.Get("oid")
|
||
typStr := params.Get("type")
|
||
pnStr := params.Get("pn")
|
||
psStr := params.Get("ps")
|
||
oid, err := strconv.ParseInt(oidStr, 10, 64)
|
||
if err != nil || oid <= 0 {
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
typ, err := strconv.ParseInt(typStr, 10, 8)
|
||
if err != nil {
|
||
err = ecode.RequestErr
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
pn, _ := strconv.Atoi(pnStr)
|
||
if pn <= 0 {
|
||
pn = 1
|
||
}
|
||
ps, _ := strconv.Atoi(psStr)
|
||
if ps > conf.Conf.Reply.MaxPageSize || ps <= 0 {
|
||
ps = 3
|
||
}
|
||
sub, rps, err := rpSvr.ReplyHots(c, oid, int8(typ), pn, ps)
|
||
if err != nil {
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
rps = rpSvr.FilDelReply(rps)
|
||
data := map[string]interface{}{
|
||
"page": map[string]int{
|
||
"num": pn,
|
||
"size": ps,
|
||
"count": sub.RCount,
|
||
"acount": sub.ACount,
|
||
},
|
||
"replies": rps,
|
||
}
|
||
c.JSON(data, nil)
|
||
}
|
||
|
||
func dialog(c *bm.Context) {
|
||
var (
|
||
err error
|
||
mid int64
|
||
escape = true
|
||
)
|
||
|
||
v := new(struct {
|
||
Oid int64 `form:"oid" validate:"required"`
|
||
Type int8 `form:"type" validate:"required"`
|
||
Dialog int64 `form:"dialog" validate:"required"`
|
||
Root int64 `form:"root" validate:"required"`
|
||
Pn int `form:"pn" validate:"min=1"`
|
||
Ps int `form:"ps" validate:"min=1"`
|
||
Plat string `form:"plat"`
|
||
Build string `form:"build"`
|
||
MobiApp string `form:"mobi_app"`
|
||
})
|
||
if err = c.Bind(v); err != nil {
|
||
return
|
||
}
|
||
if v.Ps > conf.Conf.Reply.MaxPageSize {
|
||
v.Ps = conf.Conf.Reply.MaxPageSize
|
||
}
|
||
midS, ok := c.Get("mid")
|
||
if !ok {
|
||
log.Warn("user no login")
|
||
} else {
|
||
mid = midS.(int64)
|
||
}
|
||
rps, err := rpSvr.Dialog(c, mid, v.Oid, v.Type, v.Root, v.Dialog, v.Pn, v.Ps, escape)
|
||
if err != nil {
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
data := map[string]interface{}{
|
||
"page": map[string]int{
|
||
"num": v.Pn,
|
||
"size": v.Ps,
|
||
"total": len(rps),
|
||
},
|
||
// "dialog":,
|
||
"replies": rps,
|
||
}
|
||
c.JSON(data, nil)
|
||
|
||
}
|
||
|
||
func isHotReply(c *bm.Context) {
|
||
v := new(struct {
|
||
Type int8 `form:"type" validate:"required"`
|
||
Oid int64 `form:"oid" validate:"required"`
|
||
RpID int64 `form:"rpid" validate:"required"`
|
||
})
|
||
var (
|
||
isHot bool
|
||
err error
|
||
)
|
||
if err = c.Bind(v); err != nil {
|
||
return
|
||
}
|
||
if isHot, err = rpSvr.IsHotReply(c, v.Type, v.Oid, v.RpID); err != nil {
|
||
c.JSON(nil, err)
|
||
return
|
||
}
|
||
data := map[string]bool{
|
||
"isHot": isHot,
|
||
}
|
||
c.JSON(data, nil)
|
||
}
|
||
|
||
func hotsBatch(c *bm.Context) {
|
||
v := new(struct {
|
||
Type int8 `form:"type" validate:"required"`
|
||
Oids []int64 `form:"oids,split" validate:"required"`
|
||
Size int8 `form:"size" default:"1" validate:"min=1"`
|
||
Mid int64 `form:"mid"`
|
||
})
|
||
var (
|
||
err error
|
||
)
|
||
if err = c.Bind(v); err != nil {
|
||
return
|
||
}
|
||
c.JSON(rpSvr.HotsBatch(c, v.Type, v.Size, v.Oids, v.Mid))
|
||
}
|