openbilibili/app/interface/main/account/http/relation.go

package http

import (
	"strconv"

	"go-common/app/interface/main/account/model"
	mrl "go-common/app/service/main/relation/model"
	"go-common/library/ecode"
	"go-common/library/log"
	bm "go-common/library/net/http/blademaster"
	"go-common/library/net/metadata"
	"go-common/library/xstr"
)

var (
	_defaultPS int64 = 50
)

// modify modify user relation.
func modify(c *bm.Context) {
	var (
		err      error
		act, fid int64
		src      uint64
		params   = c.Request.Form
		mid, _   = c.Get("mid")
		actStr   = params.Get("act")
		fidStr   = params.Get("fid")
		srcStr   = params.Get("re_src")
		ua       = c.Request.Header.Get("User-Agent")
		referer  = c.Request.Header.Get("Referer")
		sid      string
		realIP   = metadata.String(c, metadata.RemoteIP)
	)
	if act, err = strconv.ParseInt(actStr, 10, 8); err != nil {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	if fid, err = strconv.ParseInt(fidStr, 10, 64); err != nil || fid <= 0 {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	if src, err = strconv.ParseUint(srcStr, 10, 64); err != nil {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	sidCookie, err := c.Request.Cookie("sid")
	if err != nil {
		log.Warn("relation infoc get sid failed error(%v)", err)
	} else {
		sid = sidCookie.Value
	}
	buvid := c.Request.Header.Get("Buvid")
	if buvid == "" {
		buvidCookie, _ := c.Request.Cookie("buvid3")
		if buvidCookie != nil {
			buvid = buvidCookie.Value
		}
	}
	ric := map[string]string{
		"ip":         realIP,
		"User-Agent": ua,
		"sid":        sid,
		"buvid":      buvid,
		"Referer":    referer,
	}
	c.JSON(nil, relationSvc.Modify(c, mid.(int64), fid, int8(act), uint8(src), ric))
}

func batchModify(c *bm.Context) {
	var (
		err    error
		act    int64
		fids   []int64
		src    uint64
		params = c.Request.Form
		// res      = c.Result()
		mid, _  = c.Get("mid")
		actStr  = params.Get("act")
		fidsStr = params.Get("fids")
		srcStr  = params.Get("re_src")
		ua      = c.Request.Header.Get("User-Agent")
		referer = c.Request.Header.Get("Referer")
		sid     string
		realIP  = metadata.String(c, metadata.RemoteIP)
	)
	if act, err = strconv.ParseInt(actStr, 10, 8); err != nil {
		// res["code"] = ecode.RequestErr
		c.JSON(nil, ecode.RequestErr)
		return
	}
	if fids, err = xstr.SplitInts(fidsStr); err != nil || len(fids) <= 0 {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	if src, err = strconv.ParseUint(srcStr, 10, 64); err != nil {
		// res["code"] = ecode.RequestErr
		c.JSON(nil, ecode.RequestErr)
		return
	}
	sidCookie, err := c.Request.Cookie("sid")
	if err != nil {
		log.Warn("relation infoc get sid failed error(%v)", err)
	} else {
		sid = sidCookie.Value
	}
	buvid := c.Request.Header.Get("Buvid")
	if buvid == "" {
		buvidCookie, _ := c.Request.Cookie("buvid3")
		if buvidCookie != nil {
			buvid = buvidCookie.Value
		}
	}
	ric := map[string]string{
		"ip":         realIP,
		"User-Agent": ua,
		"sid":        sid,
		"buvid":      buvid,
		"Referer":    referer,
	}
	// res["code"] = relationSvc.Modify(c, mid.(int64), fid, int8(act), uint8(src), ric)
	c.JSON(relationSvc.BatchModify(c, mid.(int64), fids, int8(act), uint8(src), ric))
}

// relation get relation between mid and fid.
func relation(c *bm.Context) {
	var (
		err    error
		fid    int64
		f      *mrl.Following
		params = c.Request.Form
		fidStr = params.Get("fid")
		mid, _ = c.Get("mid")
	)
	if fid, err = strconv.ParseInt(fidStr, 10, 64); err != nil {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	if f, err = relationSvc.Relation(c, mid.(int64), fid); err != nil {
		log.Error("relationSvc.Relation(%d, %d) error(%v)", mid, fid, err)
		c.JSON(nil, err)
		return
	}
	c.JSON(f, nil)
}

// relations get relations between mid and fids.
func relations(c *bm.Context) {
	var (
		err     error
		fm      map[int64]*mrl.Following
		fids    []int64
		params  = c.Request.Form
		fidsStr = params.Get("fids")
		mid, _  = c.Get("mid")
	)
	if fids, err = xstr.SplitInts(fidsStr); err != nil {
		c.JSON(nil, ecode.RequestErr)
		log.Error("xstr.SplitInts(fids %v) err(%v)", fidsStr, err)
		return
	}
	if fm, err = relationSvc.Relations(c, mid.(int64), fids); err != nil {
		log.Error("relationSvc.Relations(%d, %v) error(%v)", mid, fids, err)
		c.JSON(nil, err)
		return
	}
	c.JSON(fm, nil)
}

// followings get user's following list.
func followings(c *bm.Context) {
	var (
		err        error
		mid, vmid  int64
		pn, ps     int64
		self       bool
		followings []*model.Following
		params     = c.Request.Form
		vmidStr    = params.Get("vmid")
		psStr      = params.Get("ps")
		pnStr      = params.Get("pn")
		order      = params.Get("order")
		version    uint64
		versionStr = params.Get("re_version")
		crc32v     uint32
		total      int
	)
	midS, ok := c.Get("mid")
	if ok {
		mid = midS.(int64)
	} else {
		mid = 0
	}
	if vmid, err = strconv.ParseInt(vmidStr, 10, 64); err != nil || vmid <= 0 {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	self = mid == vmid
	if pnStr != "" {
		if pn, err = strconv.ParseInt(pnStr, 10, 64); err != nil {
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if pn <= 0 {
		pn = 1
	}
	if !self && pn > 5 {
		c.JSON(nil, ecode.RelFollowingGuestLimit)
		return
	}
	if psStr != "" {
		if ps, err = strconv.ParseInt(psStr, 10, 64); err != nil {
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if ps <= 0 || ps > _defaultPS {
		ps = _defaultPS
	}
	if versionStr != "" {
		if version, err = strconv.ParseUint(versionStr, 10, 64); err != nil {
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if order != "asc" {
		order = "desc"
	}
	if followings, crc32v, total, err = relationSvc.Followings(c, vmid, mid, pn, ps, version, order); err != nil {
		log.Error("relationSvc.Followings(%d) error(%v)", vmid, err)
		c.JSON(nil, err)
		return
	}
	c.JSON(map[string]interface{}{
		"re_version": uint64(crc32v),
		"list":       followings,
		"total":      total,
	}, nil)
}

// followers get user's follower list.
func followers(c *bm.Context) {
	var (
		err        error
		mid, vmid  int64
		pn, ps     int64
		self       bool
		fs         []*model.Following
		params     = c.Request.Form
		vmidStr    = params.Get("vmid")
		psStr      = params.Get("ps")
		pnStr      = params.Get("pn")
		version    uint64
		total      int
		versionStr = params.Get("re_version")
		crc32v     uint32
	)
	midS, ok := c.Get("mid")
	if ok {
		mid = midS.(int64)
	} else {
		mid = 0
	}
	if vmid, err = strconv.ParseInt(vmidStr, 10, 64); err != nil || vmid <= 0 {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	self = mid == vmid
	if pnStr != "" {
		if pn, err = strconv.ParseInt(pnStr, 10, 64); err != nil {
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if pn <= 0 {
		pn = 1
	}
	if !self && pn > 5 {
		c.JSON(nil, ecode.RelFollowingGuestLimit)
		return
	}
	if psStr != "" {
		if ps, err = strconv.ParseInt(psStr, 10, 64); err != nil {
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if ps <= 0 || ps > _defaultPS {
		ps = _defaultPS
	}
	if versionStr != "" {
		if version, err = strconv.ParseUint(versionStr, 10, 64); err != nil {
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if fs, crc32v, total, err = relationSvc.Followers(c, vmid, mid, pn, ps, version); err != nil {
		log.Error("relationSvc.Followers(%d) error(%v)", mid, err)
		c.JSON(nil, err)
		return
	}
	c.JSON(map[string]interface{}{
		"re_version": uint64(crc32v),
		"list":       fs,
		"total":      total,
	}, nil)
}

// friends get user's friends list: follow eachother.
func friends(c *bm.Context) {
	var (
		err        error
		mid, _     = c.Get("mid")
		followings []*model.Following
		params     = c.Request.Form
		version    uint64
		versionStr = params.Get("re_version")
		crc32v     uint32
	)
	if versionStr != "" {
		if version, err = strconv.ParseUint(versionStr, 10, 64); err != nil {
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if followings, crc32v, err = relationSvc.Friends(c, mid.(int64), version); err != nil {
		log.Error("relationSvc.Followings(%d) error(%v)", mid, err)
		c.JSON(nil, err)
		return
	}
	c.JSON(map[string]interface{}{
		"re_version": uint64(crc32v),
		"list":       followings,
	}, nil)
}

// Blacks get user's black list.
func blacks(c *bm.Context) {
	var (
		err        error
		blacks     []*model.Following
		mid, _     = c.Get("mid")
		params     = c.Request.Form
		version    uint64
		pn, ps     int64
		total      int
		pnStr      = params.Get("pn")
		psStr      = params.Get("ps")
		versionStr = params.Get("re_version")
		crc32v     uint32
	)
	if versionStr != "" {
		if version, err = strconv.ParseUint(versionStr, 10, 64); err != nil {
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if pnStr != "" {
		if pn, err = strconv.ParseInt(pnStr, 10, 64); err != nil {
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if pn <= 0 {
		pn = 1
	}
	if psStr != "" {
		if ps, err = strconv.ParseInt(psStr, 10, 64); err != nil {
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if ps <= 0 || ps > _defaultPS {
		ps = _defaultPS
	}
	if blacks, crc32v, total, err = relationSvc.Blacks(c, mid.(int64), version, pn, ps); err != nil {
		log.Error("relationSvc.Blacks(%d) error(%v)", mid, err)
		c.JSON(nil, err)
		return
	}
	c.JSON(map[string]interface{}{
		"re_version": uint64(crc32v),
		"list":       blacks,
		"total":      total,
	}, nil)
}

// whispers get user's whisper list.
func whispers(c *bm.Context) {
	var (
		err        error
		pn, ps     int64
		version    uint64
		crc32v     uint32
		whispers   []*model.Following
		mid, _     = c.Get("mid")
		params     = c.Request.Form
		psStr      = params.Get("ps")
		pnStr      = params.Get("pn")
		versionStr = params.Get("re_version")
	)
	if versionStr != "" {
		if version, err = strconv.ParseUint(versionStr, 10, 64); err != nil {
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if pnStr != "" {
		if pn, err = strconv.ParseInt(pnStr, 10, 64); err != nil {
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if pn <= 0 {
		pn = 1
	}
	if psStr != "" {
		if ps, err = strconv.ParseInt(psStr, 10, 64); err != nil {
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if ps <= 0 || ps > _defaultPS {
		ps = _defaultPS
	}
	if whispers, crc32v, err = relationSvc.Whispers(c, mid.(int64), pn, ps, version); err != nil {
		log.Error("relationSvc.Whispers(%d) error(%v)", mid, err)
		c.JSON(nil, err)
		return
	}
	c.JSON(map[string]interface{}{
		"re_version": uint64(crc32v),
		"list":       whispers,
	}, nil)
}

// stat get user's follower list.
func stat(c *bm.Context) {
	var (
		err       error
		mid, vmid int64
		self      bool
		st        *mrl.Stat
		params    = c.Request.Form
		vmidStr   = params.Get("vmid")
	)
	midS, ok := c.Get("mid")
	if ok {
		mid = midS.(int64)
	} else {
		mid = 0
	}
	if vmid, err = strconv.ParseInt(vmidStr, 10, 64); err != nil || vmid <= 0 {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	self = mid == vmid
	if st, err = relationSvc.Stat(c, vmid, self); err != nil {
		log.Error("relationSvc.Followers(%d) error(%v)", mid, err)
		c.JSON(nil, err)
		return
	}
	c.JSON(st, nil)
}

// stat get user's follower list.
func stats(c *bm.Context) {
	var (
		err     error
		params  = c.Request.Form
		midsStr = params.Get("mids")
	)
	mids, err := xstr.SplitInts(midsStr)
	if err != nil || len(mids) > 20 {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	sts, err := relationSvc.Stats(c, mids)
	if err != nil {
		c.JSON(nil, err)
		return
	}
	c.JSON(sts, nil)
}

// tag 单个标签
func tag(c *bm.Context) {
	var (
		err      error
		pn, ps   int64
		mid, _   = c.Get("mid")
		params   = c.Request.Form
		tagIDStr = params.Get("tagid")
		tagid    int64
		psStr    = params.Get("ps")
		pnStr    = params.Get("pn")
		ti       []*model.Tag
	)
	if tagIDStr == "" {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	if tagid, err = strconv.ParseInt(tagIDStr, 10, 64); err != nil {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	if pnStr != "" {
		if pn, err = strconv.ParseInt(pnStr, 10, 64); err != nil {
			log.Error("pn parse")
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if pn <= 0 {
		pn = 1
	}
	if psStr != "" {
		if ps, err = strconv.ParseInt(psStr, 10, 64); err != nil {
			c.JSON(nil, ecode.RequestErr)
			return
		}
	}
	if ps <= 0 || ps > _defaultPS {
		ps = _defaultPS
	}
	if ti, err = relationSvc.Tag(c, mid.(int64), tagid, pn, ps); err != nil {
		log.Error("relationSvc.Tag(%d).tag(%d) error(%v)", mid, tagid, err)
		c.JSON(nil, err)
		return
	}
	c.JSON(ti, nil)
}

// tags 列表：标签-计数
func tags(c *bm.Context) {
	var (
		err    error
		mid, _ = c.Get("mid")
		tc     []*mrl.TagCount
	)
	if tc, err = relationSvc.Tags(c, mid.(int64)); err != nil {
		log.Error("relationSvc.Tags(%d). error(%v)", mid, err)
		c.JSON(nil, err)
		return
	}
	c.JSON(tc, nil)
}

// mobileTags 移动端 列表：标签-计数
func mobileTags(c *bm.Context) {
	var (
		err    error
		mid, _ = c.Get("mid")
		tc     map[string][]*mrl.TagCount
	)
	if tc, err = relationSvc.MobileTags(c, mid.(int64)); err != nil {
		log.Error("relationSvc.Tags(%d). error(%v)", mid, err)
		c.JSON(nil, err)
		return
	}
	c.JSON(tc, nil)
}

// tagUser 用户-fid 标签列表
func tagUser(c *bm.Context) {
	var (
		err    error
		fid    int64
		mid, _ = c.Get("mid")
		params = c.Request.Form
		fidStr = params.Get("fid")
		tc     map[int64]string
	)
	if fid, err = strconv.ParseInt(fidStr, 10, 64); err != nil || fid <= 0 {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	if tc, err = relationSvc.UserTag(c, mid.(int64), fid); err != nil {
		log.Error("relationSvc.UserTag(%d).fid(%d) error(%v)", mid, fid, err)
		c.JSON(nil, err)
		return
	}
	c.JSON(tc, nil)
}

// tagCreate create tag.
func tagCreate(c *bm.Context) {
	var (
		err    error
		mid, _ = c.Get("mid")
		params = c.Request.Form
		tagStr = params.Get("tag")
		cres   int64
	)
	if tagStr == "" {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	if cres, err = relationSvc.CreateTag(c, mid.(int64), tagStr); err != nil {
		c.JSON(nil, err)
		return
	}
	c.JSON(map[string]int64{
		"tagid": cres,
	}, nil)
}

// tagUpdate update tag.
func tagUpdate(c *bm.Context) {
	var (
		err      error
		mid, _   = c.Get("mid")
		params   = c.Request.Form
		tagIDStr = params.Get("tagid")
		tagID    int64
		newStr   = params.Get("name")
	)
	if tagIDStr == "" || newStr == "" {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	if tagID, err = strconv.ParseInt(tagIDStr, 10, 64); err != nil || tagID <= 0 {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	c.JSON(nil, relationSvc.UpdateTag(c, mid.(int64), tagID, newStr))
}

// tagDel del tag.
func tagDel(c *bm.Context) {
	var (
		err      error
		mid, _   = c.Get("mid")
		params   = c.Request.Form
		tagIDStr = params.Get("tagid")
		tagID    int64
	)
	if tagIDStr == "" {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	if tagID, err = strconv.ParseInt(tagIDStr, 10, 64); err != nil || tagID <= 0 {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	c.JSON(nil, relationSvc.DelTag(c, mid.(int64), tagID))
}

// tagsAddUsers tags add users.
func tagsAddUsers(c *bm.Context) {
	var (
		mid, _    = c.Get("mid")
		params    = c.Request.Form
		tagidsStr = params.Get("tagids")
		fidsStr   = params.Get("fids")
	)
	if tagidsStr == "" || fidsStr == "" {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	c.JSON(nil, relationSvc.TagsAddUsers(c, mid.(int64), tagidsStr, fidsStr))
}

// tagsCopyUsers tags copy users.
func tagsCopyUsers(c *bm.Context) {
	var (
		mid, _    = c.Get("mid")
		params    = c.Request.Form
		tagidsStr = params.Get("tagids")
		fidsStr   = params.Get("fids")
	)
	if tagidsStr == "" || fidsStr == "" {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	c.JSON(nil, relationSvc.TagsCopyUsers(c, mid.(int64), tagidsStr, fidsStr))
}

// tagsMoveUsers tags move users.
func tagsMoveUsers(c *bm.Context) {
	var (
		mid, _          = c.Get("mid")
		params          = c.Request.Form
		beforeTagIdsStr = params.Get("beforeTagids")
		afterTagIdsStr  = params.Get("afterTagids")
		fidsStr         = params.Get("fids")
	)
	if beforeTagIdsStr == "" || afterTagIdsStr == "" || fidsStr == "" {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	bid, err := strconv.ParseInt(beforeTagIdsStr, 10, 64)
	if err != nil {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	c.JSON(nil, relationSvc.TagsMoveUsers(c, mid.(int64), bid, afterTagIdsStr, fidsStr))
}

func prompt(c *bm.Context) {
	mid, _ := c.Get("mid")
	arg := new(mrl.ArgPrompt)
	if err := c.Bind(arg); err != nil {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	arg.Mid = mid.(int64)
	b, err := relationSvc.Prompt(c, arg)
	if err != nil {
		c.JSON(nil, err)
		return
	}
	c.JSON(map[string]interface{}{
		"prompt": b,
	}, nil)
}

func closePrompt(c *bm.Context) {
	mid, _ := c.Get("mid")
	arg := new(mrl.ArgPrompt)
	if err := c.Bind(arg); err != nil {
		return
	}
	arg.Mid = mid.(int64)
	c.JSON(nil, relationSvc.ClosePrompt(c, arg))
}

func addSpecial(c *bm.Context) {
	mid, _ := c.Get("mid")
	arg := new(mrl.ArgFollowing)
	if err := c.Bind(arg); err != nil {
		return
	}
	arg.Mid = mid.(int64)
	c.JSON(nil, relationSvc.AddSpecial(c, arg))
}
func delSpecial(c *bm.Context) {
	mid, _ := c.Get("mid")
	arg := new(mrl.ArgFollowing)
	if err := c.Bind(arg); err != nil {
		return
	}
	arg.Mid = mid.(int64)
	c.JSON(nil, relationSvc.DelSpecial(c, arg))
}
func special(c *bm.Context) {
	mid, _ := c.Get("mid")
	c.JSON(relationSvc.Special(c, mid.(int64)))
}

// recommend get global recommend upper.
// deprecated
func recommend(c *bm.Context) {
	c.JSON([]interface{}{}, nil)
}

func recommendFollowlistEmpty(c *bm.Context) {
	dev, _ := c.Get("device")
	mid, _ := c.Get("mid")
	arg := &model.ArgRecommend{}
	if err := c.Bind(arg); err != nil {
		return
	}
	arg.Device = dev.(*bm.Device)
	arg.Mid = mid.(int64)
	arg.RemoteIP = metadata.String(c, metadata.RemoteIP)
	c.JSON(relationSvc.RecommendFollowlistEmpty(c, arg))
}

func recommendAnswerOK(c *bm.Context) {
	dev, _ := c.Get("device")
	mid, _ := c.Get("mid")
	arg := &model.ArgRecommend{}
	if err := c.Bind(arg); err != nil {
		return
	}
	arg.Device = dev.(*bm.Device)
	arg.Mid = mid.(int64)
	arg.RemoteIP = metadata.String(c, metadata.RemoteIP)
	c.JSON(relationSvc.RecommendAnswerOK(c, arg))
}

func recommendTagSuggest(c *bm.Context) {
	dev, _ := c.Get("device")
	mid, _ := c.Get("mid")
	arg := &model.ArgTagSuggestRecommend{}
	if err := c.Bind(arg); err != nil {
		return
	}
	arg.Device = dev.(*bm.Device)
	arg.Mid = mid.(int64)
	arg.RemoteIP = metadata.String(c, metadata.RemoteIP)
	c.JSON(relationSvc.RecommendTagSuggest(c, arg))
}

func recommendTagSuggestDetail(c *bm.Context) {
	dev, _ := c.Get("device")
	mid, _ := c.Get("mid")
	arg := &model.ArgTagSuggestRecommend{}
	if err := c.Bind(arg); err != nil {
		return
	}
	if arg.TagName == "" {
		c.JSON(nil, ecode.RequestErr)
		return
	}
	arg.Device = dev.(*bm.Device)
	arg.Mid = mid.(int64)
	arg.RemoteIP = metadata.String(c, metadata.RemoteIP)
	c.JSON(relationSvc.RecommendTagSuggestDetail(c, arg))
}

// unread check unread status, for the 'show red point' function.
func unread(c *bm.Context) {
	var (
		err    error
		mid, _ = c.Get("mid")
		show   bool
	)
	disbaleAutoReset := c.Request.Form.Get("disableautoreset") == "1"
	if show, err = relationSvc.Unread(c, mid.(int64), disbaleAutoReset); err != nil {
		log.Error("relationSvc.Unread(%d) err(%v)", mid, err)
		c.JSON(nil, err)
		return
	}
	c.JSON(map[string]interface{}{
		"show": show,
	}, nil)
}

func unreadReset(c *bm.Context) {
	var (
		mid, _ = c.Get("mid")
	)
	c.JSON(nil, relationSvc.ResetUnread(c, mid.(int64)))
}

func unreadCount(c *bm.Context) {
	var (
		err    error
		mid, _ = c.Get("mid")
		count  int64
	)
	disbaleAutoReset := c.Request.Form.Get("disableautoreset") == "1"
	if count, err = relationSvc.UnreadCount(c, mid.(int64), disbaleAutoReset); err != nil {
		log.Error("relationSvc.UnreadCount(%d) err(%v)", mid, err)
		return
	}
	c.JSON(map[string]interface{}{
		"count": count,
	}, nil)
}

func unreadCountReset(c *bm.Context) {
	var (
		mid, _ = c.Get("mid")
	)
	c.JSON(nil, relationSvc.ResetUnreadCount(c, mid.(int64)))
}

func achieveGet(ctx *bm.Context) {
	arg := new(model.ArgAchieveGet)
	if err := ctx.Bind(arg); err != nil {
		return
	}
	mid, _ := ctx.Get("mid")
	arg.Mid = mid.(int64)
	if arg.Award != "10k" {
		ctx.JSON(nil, ecode.RequestErr)
		return
	}
	ctx.JSON(relationSvc.AchieveGet(ctx, arg))
}

func achieve(ctx *bm.Context) {
	arg := new(model.ArgAchieve)
	if err := ctx.Bind(arg); err != nil {
		return
	}
	ctx.JSON(relationSvc.Achieve(ctx, arg))
}

func followerNotifySetting(c *bm.Context) {
	var mid, _ = c.Get("mid")
	c.JSON(relationSvc.FollowerNotifySetting(c, mid.(int64)))
}

func enableFollowerNotify(c *bm.Context) {
	var mid, _ = c.Get("mid")
	c.JSON(nil, relationSvc.EnableFollowerNotify(c, mid.(int64)))
}

func disableFollowerNotify(c *bm.Context) {
	var mid, _ = c.Get("mid")
	c.JSON(nil, relationSvc.DisableFollowerNotify(c, mid.(int64)))
}

func sameFollowings(c *bm.Context) {
	arg := new(model.ArgSameFollowing)
	if err := c.Bind(arg); err != nil {
		return
	}
	mid, _ := c.Get("mid")
	arg.Mid = mid.(int64)
	if arg.Order != "asc" {
		arg.Order = "desc"
	}
	if arg.PN <= 0 {
		arg.PN = 1
	}
	if arg.PS <= 0 || arg.PS > _defaultPS {
		arg.PS = _defaultPS
	}

	followings, crc32v, total, err := relationSvc.SameFollowings(c, arg)
	if err != nil {
		log.Error("relationSvc.SameFollowings(%+v) error(%v)", arg, err)
		c.JSON(nil, err)
		return
	}
	c.JSON(map[string]interface{}{
		"re_version": uint64(crc32v),
		"list":       followings,
		"total":      total,
	}, nil)
}