You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
482 lines
12 KiB
482 lines
12 KiB
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 |
|
}
|
|
|