go-common/app/interface/main/space/service/account.go

383 lines
10 KiB
Go
Raw Normal View History

2019-04-22 10:49:16 +00:00
package service
import (
"context"
"encoding/json"
"go-common/app/interface/main/space/model"
tagmdl "go-common/app/interface/main/tag/model"
artmdl "go-common/app/interface/openplatform/article/model"
accwar "go-common/app/service/main/account/api"
accmdl "go-common/app/service/main/account/model"
favmdl "go-common/app/service/main/favorite/model"
memmdl "go-common/app/service/main/member/model"
relmdl "go-common/app/service/main/relation/model"
upmdl "go-common/app/service/main/up/api/v1"
"go-common/library/conf/env"
"go-common/library/ecode"
"go-common/library/log"
"go-common/library/net/metadata"
"go-common/library/sync/errgroup"
)
const (
_samplePn = 1
_samplePs = 1
_silenceForbid = 1
_accBlockDefault = 0
_accBlockDue = 1
_officialNoType = -1
_audioCardOn = 1
_noticeForbid = 1
)
var (
_emptyThemeList = make([]*model.ThemeDetail, 0)
_emptyArcItem = make([]*model.ArcItem, 0)
)
// NavNum get space nav num by mid.
func (s *Service) NavNum(c context.Context, mid, vmid int64) (res *model.NavNum) {
ip := metadata.String(c, metadata.RemoteIP)
res = new(model.NavNum)
group, errCtx := errgroup.WithContext(c)
group.Go(func() error {
if reply, err := s.upClient.UpCount(errCtx, &upmdl.UpCountReq{Mid: vmid}); err != nil {
log.Error("s.upClient.UpCount(%d) error(%v)", vmid, err)
} else if reply.Count > 0 {
res.Video = reply.Count
}
return nil
})
group.Go(func() error {
res.Channel = new(model.Num)
if chs, err := s.ChannelList(errCtx, vmid, false); err != nil {
log.Error("s.ChannelList(%d) error(%v)", vmid, err)
} else if chCnt := len(chs); chCnt > 0 {
res.Channel.Master = chCnt
for _, v := range chs {
if v.Count > 0 {
res.Channel.Guest++
}
}
}
return nil
})
group.Go(func() error {
res.Favourite = new(model.Num)
if favs, err := s.dao.FavFolder(errCtx, mid, vmid); err != nil {
log.Error("s.dao.FavFolder(%d) error(%v)", vmid, err)
} else if favCnt := len(favs); favCnt > 0 {
res.Favourite.Master = favCnt
for _, v := range favs {
if v.IsPublic() {
res.Favourite.Guest++
}
}
}
return nil
})
group.Go(func() error {
if _, cnt, err := s.dao.BangumiList(errCtx, vmid, _samplePn, _samplePs); err != nil {
log.Error("s.dao.BangumiList(%d) error(%v)", vmid, err)
} else if cnt > 0 {
res.Bangumi = cnt
}
return nil
})
group.Go(func() error {
if tag, err := s.tag.SubTags(errCtx, &tagmdl.ArgSub{Mid: vmid, Pn: _samplePn, Ps: _samplePs, RealIP: ip}); err != nil {
log.Error("s.tag.SubTags(%d) error(%v)", vmid, err)
} else if tag != nil {
res.Tag = tag.Total
}
return nil
})
group.Go(func() error {
if art, err := s.art.UpArtMetas(errCtx, &artmdl.ArgUpArts{Mid: vmid, Pn: 1, Ps: 10, RealIP: ip}); err != nil {
log.Error("s.art.UpArtMetas(%d) error(%v)", vmid, err)
} else if art != nil {
res.Article = art.Count
}
return nil
})
group.Go(func() error {
if cnt, err := s.fav.CntUserFolders(errCtx, &favmdl.ArgCntUserFolders{Type: favmdl.TypePlayVideo, Mid: vmid, RealIP: ip}); err != nil {
log.Error("s.dao.Playlist(%d) error(%v)", vmid, err)
} else if cnt > 0 {
res.Playlist = cnt
}
return nil
})
group.Go(func() error {
if cnt, err := s.dao.AlbumCount(errCtx, vmid); err == nil && cnt > 0 {
res.Album = cnt
}
return nil
})
group.Go(func() error {
if cnt, err := s.dao.AudioCnt(errCtx, vmid); err != nil {
log.Error("s.dao.AudioCnt(%d) error(%v)", vmid, err)
} else if cnt > 0 {
res.Audio = cnt
}
return nil
})
group.Wait()
return
}
// UpStat get up stat.
func (s *Service) UpStat(c context.Context, mid int64) (res *model.UpStat, err error) {
var (
info *accwar.InfoReply
arcStat *model.UpArcStat
artStat *model.UpArtStat
arcErr, artErr error
)
if info, err = s.accClient.Info3(c, &accwar.MidReq{Mid: mid}); err != nil || info == nil {
log.Error("s.accClient.Info3(%d) error(%v)", mid, err)
return
}
res = new(model.UpStat)
group, errCtx := errgroup.WithContext(c)
group.Go(func() error {
if arcStat, arcErr = s.UpArcStat(errCtx, mid); arcErr != nil {
log.Error("s.UpArcStat(%d) error(%v)", mid, arcErr)
} else if arcStat != nil {
res.Archive.View = arcStat.View
}
return nil
})
group.Go(func() error {
if artStat, artErr = s.UpArtStat(errCtx, mid); artErr != nil {
log.Error("s.UpArtStat(%d) error(%v)", mid, artErr)
} else if artStat != nil {
res.Article.View = artStat.View
}
return nil
})
group.Wait()
return
}
// MyInfo get my info.
func (s *Service) MyInfo(c context.Context, mid int64) (res *accmdl.ProfileStat, err error) {
var reply *accwar.ProfileStatReply
if reply, err = s.accClient.ProfileWithStat3(c, &accwar.MidReq{Mid: mid}); err != nil {
log.Error("s.accClient.ProfileWithStat3(%d) error(%v)", mid, err)
return
}
level := memmdl.LevelInfo{
Cur: reply.LevelInfo.Cur,
Min: reply.LevelInfo.Min,
NowExp: reply.LevelInfo.NowExp,
NextExp: reply.LevelInfo.NextExp,
}
res = &accmdl.ProfileStat{
Profile: reply.Profile,
LevelExp: level,
Coins: reply.Coins,
Following: reply.Follower,
Follower: reply.Follower,
}
return
}
// AccTags get account tags.
func (s *Service) AccTags(c context.Context, mid int64) (res json.RawMessage, err error) {
return s.dao.AccTags(c, mid)
}
// SetAccTags set account tags.
func (s *Service) SetAccTags(c context.Context, tags, ck string) (err error) {
return s.dao.SetAccTags(c, tags, ck)
}
// AccInfo web acc info.
func (s *Service) AccInfo(c context.Context, mid, vmid int64) (res *model.AccInfo, err error) {
if env.DeployEnv == env.DeployEnvProd {
if _, ok := s.BlacklistValue[vmid]; ok {
err = ecode.NothingFound
return
}
}
var (
reply *accwar.ProfileStatReply
topPhoto *model.TopPhoto
topErr error
)
if reply, err = s.accClient.ProfileWithStat3(c, &accwar.MidReq{Mid: vmid}); err != nil || reply == nil {
log.Error("s.accClient.ProfileWithStat3(%d) error(%v)", vmid, err)
if ecode.Cause(err) != ecode.UserNotExist {
return
}
reply = model.DefaultProfileStat
}
res = new(model.AccInfo)
res.FromCard(reply)
if res.Mid == 0 {
res.Mid = vmid
}
group, errCtx := errgroup.WithContext(c)
//check privacy
if mid != vmid {
group.Go(func() error {
if privacyErr := s.privacyCheck(errCtx, vmid, model.PcyUserInfo); privacyErr != nil {
res.JoinTime = 0
res.Sex = "保密"
res.Birthday = ""
}
return nil
})
if mid > 0 {
group.Go(func() error {
if relation, err := s.accClient.Relation3(errCtx, &accwar.RelationReq{Mid: mid, Owner: vmid}); err != nil {
log.Error("s.accClient.Relation3(%d,%d) error (%v)", mid, vmid, err)
} else if relation != nil {
res.IsFollowed = relation.Following
}
return nil
})
}
}
//get top photo
group.Go(func() error {
topPhoto, topErr = s.dao.WebTopPhoto(errCtx, vmid)
return nil
})
//get all theme
group.Go(func() error {
res.Theme = struct{}{}
if theme, err := s.dao.Theme(errCtx, vmid); err == nil && theme != nil && len(theme.List) > 0 {
for _, v := range theme.List {
if v.IsActivated == 1 {
res.Theme = v
break
}
}
}
return nil
})
//get live metal
group.Go(func() error {
res.FansBadge, _ = s.dao.LiveMetal(errCtx, vmid)
return nil
})
group.Wait()
if topErr != nil || topPhoto == nil || topPhoto.LImg == "" {
res.TopPhoto = s.c.Rule.TopPhoto
} else {
res.TopPhoto = topPhoto.LImg
}
return
}
// ThemeList get theme list.
func (s *Service) ThemeList(c context.Context, mid int64) (data []*model.ThemeDetail, err error) {
var theme *model.ThemeDetails
if theme, err = s.dao.Theme(c, mid); err != nil {
return
}
if theme == nil || len(theme.List) == 0 {
data = _emptyThemeList
return
}
data = theme.List
return
}
// ThemeActive theme active.
func (s *Service) ThemeActive(c context.Context, mid, themeID int64) (err error) {
var (
theme *model.ThemeDetails
check bool
)
if theme, err = s.dao.Theme(c, mid); err != nil {
return
}
if theme == nil || len(theme.List) == 0 {
err = ecode.RequestErr
return
}
for _, v := range theme.List {
if v.ID == themeID {
if v.IsActivated == 1 {
err = ecode.NotModified
return
}
check = true
}
}
if !check {
err = ecode.RequestErr
return
}
if err = s.dao.ThemeActive(c, mid, themeID); err == nil {
s.dao.DelCacheTheme(c, mid)
}
return
}
// Relation .
func (s *Service) Relation(c context.Context, mid, vmid int64) (data *model.Relation) {
data = &model.Relation{Relation: struct{}{}, BeRelation: struct{}{}}
ip := metadata.String(c, metadata.RemoteIP)
if mid == vmid {
return
}
group, errCtx := errgroup.WithContext(c)
group.Go(func() error {
if relation, err := s.relation.Relation(errCtx, &relmdl.ArgRelation{Mid: mid, Fid: vmid, RealIP: ip}); err != nil {
log.Error("Relation s.relation.Relation(Mid:%d,Fid:%d,%s) error %v", mid, vmid, ip, err)
} else if relation != nil {
data.Relation = relation
}
return nil
})
group.Go(func() error {
if beRelation, err := s.relation.Relation(errCtx, &relmdl.ArgRelation{Mid: vmid, Fid: mid, RealIP: ip}); err != nil {
log.Error("Relation s.relation.Relation(Mid:%d,Fid:%d,%s) error %v", vmid, mid, ip, err)
} else if beRelation != nil {
data.BeRelation = beRelation
}
return nil
})
group.Wait()
return
}
// WebIndex web index.
func (s *Service) WebIndex(c context.Context, mid, vmid int64, pn, ps int32) (data *model.WebIndex, err error) {
data = new(model.WebIndex)
group, errCtx := errgroup.WithContext(c)
group.Go(func() error {
info, infoErr := s.AccInfo(errCtx, mid, vmid)
if infoErr != nil {
return infoErr
}
data.Account = info
return nil
})
group.Go(func() error {
if setting, e := s.SettingInfo(errCtx, vmid); e == nil {
data.Setting = setting
}
return nil
})
group.Go(func() error {
if upArc, e := s.UpArcs(errCtx, vmid, pn, ps); e != nil {
data.Archive = &model.WebArc{Archives: _emptyArcItem}
} else {
arc := &model.WebArc{
Page: model.WebPage{Pn: pn, Ps: ps, Count: upArc.Count},
Archives: upArc.List,
}
data.Archive = arc
}
return nil
})
err = group.Wait()
return
}