483 lines
12 KiB
Go
483 lines
12 KiB
Go
package space
|
|
|
|
import (
|
|
"context"
|
|
"sort"
|
|
"time"
|
|
|
|
"go-common/app/interface/main/app-interface/model"
|
|
"go-common/app/interface/main/app-interface/model/audio"
|
|
"go-common/app/interface/main/app-interface/model/bplus"
|
|
"go-common/app/interface/main/app-interface/model/space"
|
|
article "go-common/app/interface/openplatform/article/model"
|
|
"go-common/app/service/main/archive/api"
|
|
"go-common/library/log"
|
|
"go-common/library/sync/errgroup"
|
|
xtime "go-common/library/time"
|
|
)
|
|
|
|
const (
|
|
_androidAudio = 516009
|
|
_iosAudio = 6160
|
|
)
|
|
|
|
// Contribute func
|
|
func (s *Service) Contribute(c context.Context, plat int8, build int, vmid int64, pn, ps int, now time.Time) (res *space.Contributes, err error) {
|
|
var (
|
|
attrs *space.Attrs
|
|
items []*space.Item
|
|
)
|
|
if pn == 1 {
|
|
var (
|
|
ctime xtime.Time
|
|
cached bool
|
|
)
|
|
size := ps
|
|
if items, err = s.bplusDao.RangeContributeCache(c, vmid, pn, ps); err != nil {
|
|
log.Error("%+v", err)
|
|
} else if len(items) != 0 {
|
|
ctime = items[0].CTime
|
|
} else {
|
|
size = 100
|
|
cached = true
|
|
}
|
|
if res, err = s.firstContribute(c, vmid, size, now); err != nil {
|
|
log.Error("%+v", err)
|
|
err = nil
|
|
}
|
|
if res != nil && len(res.Items) != 0 {
|
|
if res.Items[0].CTime > ctime {
|
|
if err = s.bplusDao.NotifyContribute(c, vmid, nil, ctime); err != nil {
|
|
log.Error("%+v", err)
|
|
err = nil
|
|
}
|
|
}
|
|
if cached {
|
|
ris := res.Items
|
|
s.addCache(func() {
|
|
s.bplusDao.AddContributeCache(context.Background(), vmid, nil, ris)
|
|
})
|
|
}
|
|
if len(items) == 0 {
|
|
ris := make([]*space.Item, 0, ps)
|
|
for _, item := range res.Items {
|
|
item.FormatKey()
|
|
switch item.Goto {
|
|
case model.GotoAudio:
|
|
if (plat == model.PlatAndroid && build > _androidAudio) || (plat == model.PlatIPhone && build > _iosAudio) || plat == model.PlatAndroidB {
|
|
ris = append(ris, item)
|
|
}
|
|
default:
|
|
ris = append(ris, item)
|
|
}
|
|
if len(ris) == ps {
|
|
break
|
|
}
|
|
}
|
|
res.Items = ris
|
|
return
|
|
}
|
|
}
|
|
} else {
|
|
if items, err = s.bplusDao.RangeContributeCache(c, vmid, pn, ps); err != nil {
|
|
return
|
|
}
|
|
}
|
|
if len(items) != 0 {
|
|
if attrs, err = s.bplusDao.AttrCache(c, vmid); err != nil {
|
|
log.Error("%+v", err)
|
|
}
|
|
// merge res
|
|
if res, err = s.dealContribute(c, plat, build, vmid, attrs, items, now); err != nil {
|
|
log.Error("%+v", err)
|
|
}
|
|
}
|
|
if res == nil {
|
|
res = &space.Contributes{Tab: &space.Tab{}, Items: []*space.Item{}, Links: &space.Links{}}
|
|
}
|
|
return
|
|
}
|
|
|
|
// Contribution func
|
|
func (s *Service) Contribution(c context.Context, plat int8, build int, vmid int64, cursor *model.Cursor, now time.Time) (res *space.Contributes, err error) {
|
|
var (
|
|
attrs *space.Attrs
|
|
items []*space.Item
|
|
)
|
|
if cursor.Latest() {
|
|
var (
|
|
ctime xtime.Time
|
|
cached bool
|
|
)
|
|
size := cursor.Size
|
|
if items, err = s.bplusDao.RangeContributeCache(c, vmid, 1, 1); err != nil {
|
|
log.Error("%+v", err)
|
|
} else if len(items) != 0 {
|
|
ctime = items[0].CTime
|
|
} else {
|
|
size = 100
|
|
cached = true
|
|
}
|
|
if res, err = s.firstContribute(c, vmid, size, now); err != nil {
|
|
log.Error("%+v", err)
|
|
}
|
|
if res != nil && len(res.Items) != 0 {
|
|
if cached {
|
|
ris := res.Items
|
|
s.addCache(func() {
|
|
s.bplusDao.AddContributeCache(context.Background(), vmid, nil, ris)
|
|
})
|
|
}
|
|
if res.Items[0].CTime > ctime {
|
|
if len(items) != 0 {
|
|
if attrs, err = s.bplusDao.AttrCache(c, vmid); err != nil {
|
|
log.Error("%+v", err)
|
|
}
|
|
}
|
|
if err = s.bplusDao.NotifyContribute(c, vmid, attrs, ctime); err != nil {
|
|
log.Error("%+v", err)
|
|
err = nil
|
|
}
|
|
}
|
|
ris := make([]*space.Item, 0, cursor.Size)
|
|
for _, item := range res.Items {
|
|
item.FormatKey()
|
|
ris = append(ris, item)
|
|
if len(ris) == cursor.Size {
|
|
break
|
|
}
|
|
}
|
|
if len(ris) != 0 {
|
|
res.Items = ris
|
|
res.Links.Link(0, int64(ris[len(ris)-1].Member))
|
|
}
|
|
return
|
|
}
|
|
}
|
|
if items, err = s.bplusDao.RangeContributionCache(c, vmid, cursor); err != nil {
|
|
return
|
|
}
|
|
if len(items) != 0 {
|
|
if attrs, err = s.bplusDao.AttrCache(c, vmid); err != nil {
|
|
log.Error("%+v", err)
|
|
}
|
|
// merge res
|
|
if res, err = s.dealContribute(c, plat, build, vmid, attrs, items, now); err != nil {
|
|
log.Error("%+v", err)
|
|
}
|
|
}
|
|
if res == nil {
|
|
res = &space.Contributes{Tab: &space.Tab{}, Items: []*space.Item{}, Links: &space.Links{}}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) firstContribute(c context.Context, vmid int64, size int, now time.Time) (res *space.Contributes, err error) {
|
|
res = &space.Contributes{Tab: &space.Tab{}, Items: []*space.Item{}, Links: &space.Links{}}
|
|
g, ctx := errgroup.WithContext(c)
|
|
var arcItem, artItem, clipItem, albumItem, audioItem, items []*space.Item
|
|
g.Go(func() (err error) {
|
|
var arcs []*api.Arc
|
|
if arcs, err = s.arcDao.UpArcs3(ctx, vmid, 1, size); err != nil {
|
|
log.Error("s.arcDao.UpArcs3(%d,%d,%d) error(%v)", vmid, 1, size, err)
|
|
err = nil
|
|
return
|
|
}
|
|
if len(arcs) != 0 {
|
|
arcItem = make([]*space.Item, 0, len(arcs))
|
|
for _, v := range arcs {
|
|
if v.IsNormal() {
|
|
si := &space.Item{}
|
|
si.FromArc3(v)
|
|
arcItem = append(arcItem, si)
|
|
}
|
|
}
|
|
}
|
|
return
|
|
})
|
|
g.Go(func() (err error) {
|
|
var arts []*article.Meta
|
|
if arts, _, err = s.artDao.UpArticles(ctx, vmid, 1, size); err != nil {
|
|
log.Error("s.artDao.UpArticles(%d,%d,%d) error(%v)", vmid, 1, size, err)
|
|
err = nil
|
|
return
|
|
}
|
|
if len(arts) != 0 {
|
|
artItem = make([]*space.Item, 0, len(arts))
|
|
for _, v := range arts {
|
|
if v.AttrVal(article.AttrBitNoDistribute) {
|
|
continue
|
|
}
|
|
si := &space.Item{}
|
|
si.FromArticle(v)
|
|
artItem = append(artItem, si)
|
|
}
|
|
}
|
|
return
|
|
})
|
|
g.Go(func() (err error) {
|
|
var clips []*bplus.Clip
|
|
if clips, _, err = s.bplusDao.AllClip(c, vmid, size); err != nil {
|
|
log.Error("s.bplusDao.AllClip(%d,%d) error(%v)", vmid, size, err)
|
|
err = nil
|
|
return
|
|
}
|
|
if len(clips) != 0 {
|
|
clipItem = make([]*space.Item, 0, len(clips))
|
|
for _, v := range clips {
|
|
si := &space.Item{}
|
|
si.FromClip(v)
|
|
clipItem = append(clipItem, si)
|
|
}
|
|
}
|
|
return
|
|
})
|
|
g.Go(func() (err error) {
|
|
var album []*bplus.Album
|
|
if album, _, err = s.bplusDao.AllAlbum(c, vmid, size); err != nil {
|
|
log.Error("s.bplusDao.AllAlbum(%d,%d) error(%v)", vmid, size, err)
|
|
err = nil
|
|
return
|
|
}
|
|
if len(album) != 0 {
|
|
albumItem = make([]*space.Item, 0, len(album))
|
|
for _, v := range album {
|
|
si := &space.Item{}
|
|
si.FromAlbum(v)
|
|
albumItem = append(albumItem, si)
|
|
}
|
|
}
|
|
return
|
|
})
|
|
g.Go(func() (err error) {
|
|
var audio []*audio.Audio
|
|
if audio, err = s.audioDao.AllAudio(c, vmid); err != nil {
|
|
log.Error("s.audioDao.AllAudio(%d) error(%v)", vmid, err)
|
|
err = nil
|
|
return
|
|
}
|
|
if len(audio) != 0 {
|
|
audioItem = make([]*space.Item, 0, len(audio))
|
|
for _, v := range audio {
|
|
si := &space.Item{}
|
|
si.FromAudio(v)
|
|
audioItem = append(audioItem, si)
|
|
}
|
|
}
|
|
return
|
|
})
|
|
if err = g.Wait(); err != nil {
|
|
log.Error("Contribute errgroup.WithContext error(%v)", err)
|
|
}
|
|
items = make([]*space.Item, 0, len(arcItem)+len(artItem)+len(clipItem)+len(albumItem)+len(audioItem))
|
|
if len(arcItem) != 0 {
|
|
res.Tab.Archive = true
|
|
items = append(items, arcItem...)
|
|
}
|
|
if len(artItem) != 0 {
|
|
res.Tab.Article = true
|
|
items = append(items, artItem...)
|
|
}
|
|
if len(clipItem) != 0 {
|
|
res.Tab.Clip = true
|
|
items = append(items, clipItem...)
|
|
}
|
|
if len(albumItem) != 0 {
|
|
res.Tab.Album = true
|
|
items = append(items, albumItem...)
|
|
}
|
|
if len(audioItem) != 0 {
|
|
res.Tab.Audios = true
|
|
items = append(items, audioItem...)
|
|
}
|
|
sort.Sort(space.Items(items))
|
|
res.Items = items
|
|
return
|
|
}
|
|
|
|
func (s *Service) dealContribute(c context.Context, plat int8, build int, vmid int64, attrs *space.Attrs, items []*space.Item, now time.Time) (res *space.Contributes, err error) {
|
|
res = &space.Contributes{Tab: &space.Tab{}, Items: []*space.Item{}, Links: &space.Links{}}
|
|
var aids, cvids, clids, alids, auids []int64
|
|
if attrs == nil {
|
|
attrs = &space.Attrs{}
|
|
} else if !((plat == model.PlatAndroid && build > _androidAudio) || (plat == model.PlatIPhone && build > _iosAudio) || plat == model.PlatAndroidB) {
|
|
attrs.Audio = false
|
|
}
|
|
for _, item := range items {
|
|
if item.ID == 0 {
|
|
continue
|
|
}
|
|
switch item.Goto {
|
|
case model.GotoAv:
|
|
aids = append(aids, item.ID)
|
|
case model.GotoArticle:
|
|
cvids = append(cvids, item.ID)
|
|
case model.GotoClip:
|
|
clids = append(clids, item.ID)
|
|
case model.GotoAlbum:
|
|
alids = append(alids, item.ID)
|
|
case model.GotoAudio:
|
|
if (plat == model.PlatAndroid && build > _androidAudio) || (plat == model.PlatIPhone && build > _iosAudio) || plat == model.PlatAndroidB {
|
|
auids = append(auids, item.ID)
|
|
}
|
|
}
|
|
}
|
|
var (
|
|
am map[int64]*api.Arc
|
|
atm map[int64]*article.Meta
|
|
clm map[int64]*bplus.Clip
|
|
alm map[int64]*bplus.Album
|
|
aum map[int64]*audio.Audio
|
|
)
|
|
g, ctx := errgroup.WithContext(c)
|
|
if len(aids) != 0 {
|
|
g.Go(func() (err error) {
|
|
if am, err = s.arcDao.Archives2(ctx, aids); err != nil {
|
|
log.Error("s.arcDao.Archives(%v) error(%v)", aids, err)
|
|
err = nil
|
|
}
|
|
return
|
|
})
|
|
}
|
|
if len(cvids) != 0 {
|
|
g.Go(func() (err error) {
|
|
if atm, err = s.artDao.Articles(ctx, cvids); err != nil {
|
|
log.Error("s.artDao.Articles(%v) error(%v)", cvids, err)
|
|
err = nil
|
|
}
|
|
return
|
|
})
|
|
}
|
|
if len(clids) != 0 {
|
|
g.Go(func() (err error) {
|
|
if clm, err = s.bplusDao.ClipDetail(ctx, clids); err != nil {
|
|
log.Error("s.bplusDao.ClipDetail(%v) error(%v)", clids, err)
|
|
err = nil
|
|
}
|
|
return
|
|
})
|
|
}
|
|
if len(alids) != 0 {
|
|
g.Go(func() (err error) {
|
|
if alm, err = s.bplusDao.AlbumDetail(ctx, vmid, alids); err != nil {
|
|
log.Error("s.bplusDao.AlbumDetail(%v) error(%v)", alids, err)
|
|
err = nil
|
|
}
|
|
return
|
|
})
|
|
}
|
|
if len(auids) != 0 {
|
|
g.Go(func() (err error) {
|
|
if aum, err = s.audioDao.AudioDetail(c, auids); err != nil {
|
|
log.Error("s.audioDao.AudioDetail(%v) error(%v)", auids, err)
|
|
err = nil
|
|
}
|
|
return
|
|
})
|
|
}
|
|
if err = g.Wait(); err != nil {
|
|
log.Error("Contribute errgroup.WithContext error(%v)", err)
|
|
return
|
|
}
|
|
if len(am) != 0 || attrs.Archive {
|
|
res.Tab.Archive = true
|
|
}
|
|
if len(atm) != 0 || attrs.Article {
|
|
res.Tab.Article = true
|
|
}
|
|
if len(clm) != 0 || attrs.Clip {
|
|
res.Tab.Clip = true
|
|
}
|
|
if len(alm) != 0 || attrs.Album {
|
|
res.Tab.Album = true
|
|
}
|
|
if len(aum) != 0 || attrs.Audio {
|
|
res.Tab.Audios = true
|
|
}
|
|
ris := make([]*space.Item, 0, len(items))
|
|
for _, item := range items {
|
|
ri := &space.Item{}
|
|
switch item.Goto {
|
|
case model.GotoAv:
|
|
if a, ok := am[item.ID]; ok && a.IsNormal() {
|
|
ri.FromArc3(a)
|
|
}
|
|
case model.GotoArticle:
|
|
if at, ok := atm[item.ID]; ok {
|
|
ri.FromArticle(at)
|
|
}
|
|
case model.GotoClip:
|
|
if cl, ok := clm[item.ID]; ok {
|
|
ri.FromClip(cl)
|
|
}
|
|
case model.GotoAlbum:
|
|
if al, ok := alm[item.ID]; ok {
|
|
ri.FromAlbum(al)
|
|
}
|
|
case model.GotoAudio:
|
|
if au, ok := aum[item.ID]; ok {
|
|
ri.FromAudio(au)
|
|
}
|
|
}
|
|
if ri.Goto != "" {
|
|
ri.FormatKey()
|
|
ris = append(ris, ri)
|
|
}
|
|
}
|
|
res.Items = ris
|
|
res.Links.Link(int64(items[0].Member), int64(items[len(items)-1].Member))
|
|
return
|
|
}
|
|
|
|
// Clip func
|
|
func (s *Service) Clip(c context.Context, vmid int64, pos, size int) (res *space.ClipList) {
|
|
var (
|
|
clips []*bplus.Clip
|
|
err error
|
|
)
|
|
res = &space.ClipList{Item: []*space.Item{}}
|
|
if clips, res.More, res.Offset, err = s.bplusDao.Clips(c, vmid, pos, size); err != nil {
|
|
log.Error("%+v", err)
|
|
return
|
|
}
|
|
if len(clips) > 0 {
|
|
res.Item = make([]*space.Item, 0, len(clips))
|
|
for _, v := range clips {
|
|
si := &space.Item{}
|
|
si.FromClip(v)
|
|
res.Item = append(res.Item, si)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// Album func
|
|
func (s *Service) Album(c context.Context, vmid int64, pos, size int) (res *space.AlbumList) {
|
|
var (
|
|
albums []*bplus.Album
|
|
err error
|
|
)
|
|
res = &space.AlbumList{Item: []*space.Item{}}
|
|
if albums, res.More, res.Offset, err = s.bplusDao.Albums(c, vmid, pos, size); err != nil {
|
|
log.Error("%+v", err)
|
|
return
|
|
}
|
|
if len(albums) > 0 {
|
|
res.Item = make([]*space.Item, 0, len(albums))
|
|
for _, v := range albums {
|
|
si := &space.Item{}
|
|
si.FromAlbum(v)
|
|
res.Item = append(res.Item, si)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// AddContribute func
|
|
func (s *Service) AddContribute(c context.Context, vmid int64, attrs *space.Attrs, items []*space.Item) (err error) {
|
|
if err = s.bplusDao.AddContributeCache(c, vmid, attrs, items); err != nil {
|
|
log.Error("%+v", err)
|
|
}
|
|
return
|
|
}
|