368 lines
10 KiB
Go
368 lines
10 KiB
Go
|
package service
|
||
|
|
|
||
|
|
import (
|
||
|
|
"context"
|
||
|
|
"sync"
|
||
|
|
"time"
|
||
|
|
|
||
|
|
"go-common/app/interface/main/space/conf"
|
||
|
|
"go-common/app/interface/main/space/model"
|
||
|
|
arcmdl "go-common/app/service/main/archive/api"
|
||
|
|
"go-common/library/ecode"
|
||
|
|
"go-common/library/log"
|
||
|
|
"go-common/library/sync/errgroup"
|
||
|
|
xtime "go-common/library/time"
|
||
|
|
)
|
||
|
|
|
||
|
|
const _aidBulkSize = 50
|
||
|
|
|
||
|
|
// AddChannelArc add channel archive.
|
||
|
|
func (s *Service) AddChannelArc(c context.Context, mid, cid int64, aids []int64) (fakeAids []int64, err error) {
|
||
|
|
var (
|
||
|
|
lastID int64
|
||
|
|
orderNum int
|
||
|
|
chAids, addAids []int64
|
||
|
|
arcs map[int64]*arcmdl.Arc
|
||
|
|
videos []*model.ChannelArc
|
||
|
|
videoMap map[int64]int64
|
||
|
|
remainVideos []*model.ChannelArcSort
|
||
|
|
ts = time.Now()
|
||
|
|
)
|
||
|
|
fakeAids = make([]int64, 0)
|
||
|
|
if _, _, err = s.channel(c, mid, cid); err != nil {
|
||
|
|
log.Error("s.dao.Channel(%d,%d) error(%v)", mid, cid, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if videos, err = s.dao.ChannelVideos(c, mid, cid, false); err != nil {
|
||
|
|
log.Error("s.dao.channelVideos(%d,%d) error(%v)", mid, cid, err)
|
||
|
|
return
|
||
|
|
} else if orderNum = len(videos); orderNum > 0 {
|
||
|
|
if len(aids)+orderNum > conf.Conf.Rule.MaxChArcLimit {
|
||
|
|
err = ecode.ChMaxArcCount
|
||
|
|
return
|
||
|
|
}
|
||
|
|
videoMap = make(map[int64]int64)
|
||
|
|
for _, video := range videos {
|
||
|
|
chAids = append(chAids, video.Aid)
|
||
|
|
videoMap[video.Aid] = video.Aid
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for _, aid := range aids {
|
||
|
|
if _, ok := videoMap[aid]; ok {
|
||
|
|
fakeAids = append(fakeAids, aid)
|
||
|
|
} else {
|
||
|
|
addAids = append(addAids, aid)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if len(addAids) == 0 {
|
||
|
|
err = ecode.ChAidsExist
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = s.arcsCheck(c, mid, chAids); err != nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if arcs, err = s.archives(c, addAids); err != nil {
|
||
|
|
log.Error("s.arc.Archive3(%v) error(%v)", addAids, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for _, aid := range addAids {
|
||
|
|
if arc, ok := arcs[aid]; !ok || !arc.IsNormal() || arc.Author.Mid != mid {
|
||
|
|
fakeAids = append(fakeAids, aid)
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
orderNum++
|
||
|
|
remainVideos = append(remainVideos, &model.ChannelArcSort{Aid: aid, OrderNum: orderNum})
|
||
|
|
}
|
||
|
|
if len(remainVideos) == 0 {
|
||
|
|
err = ecode.ChAidsExist
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if lastID, err = s.dao.AddChannelArc(c, mid, cid, ts, remainVideos); err != nil {
|
||
|
|
log.Error("s.dao.AddChannelArc(mid:%d,cid:%d) error(%v)", mid, cid, err)
|
||
|
|
return
|
||
|
|
} else if lastID > 0 {
|
||
|
|
var arcs []*model.ChannelArc
|
||
|
|
for _, v := range remainVideos {
|
||
|
|
arc := &model.ChannelArc{ID: lastID, Mid: mid, Cid: cid, Aid: v.Aid, OrderNum: v.OrderNum, Mtime: xtime.Time(ts.Unix())}
|
||
|
|
arcs = append(arcs, arc)
|
||
|
|
}
|
||
|
|
s.dao.AddChannelArcCache(context.Background(), mid, cid, arcs)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *Service) arcsCheck(c context.Context, mid int64, aids []int64) (err error) {
|
||
|
|
var arcs map[int64]*arcmdl.Arc
|
||
|
|
if arcs, err = s.archives(c, aids); err != nil {
|
||
|
|
log.Error("s.archives error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for _, aid := range aids {
|
||
|
|
if arc, ok := arcs[aid]; !ok || !arc.IsNormal() || arc.Author.Mid != mid {
|
||
|
|
err = ecode.ChFakeAid
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// DelChannelArc delete channel archive.
|
||
|
|
func (s *Service) DelChannelArc(c context.Context, mid, cid, aid int64) (err error) {
|
||
|
|
var (
|
||
|
|
affected int64
|
||
|
|
orderNum int
|
||
|
|
videos []*model.ChannelArc
|
||
|
|
)
|
||
|
|
if videos, err = s.dao.ChannelVideos(c, mid, cid, false); err != nil {
|
||
|
|
log.Error("s.dao.Channel(%d,%d) error(%v)", mid, cid, err)
|
||
|
|
return
|
||
|
|
} else if len(videos) == 0 {
|
||
|
|
err = ecode.ChNoArcs
|
||
|
|
return
|
||
|
|
} else {
|
||
|
|
check := false
|
||
|
|
for _, video := range videos {
|
||
|
|
if aid == video.Aid {
|
||
|
|
check = true
|
||
|
|
orderNum = video.OrderNum
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if !check {
|
||
|
|
err = ecode.ChNoArc
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if affected, err = s.dao.DelChannelArc(c, mid, cid, aid, orderNum); err != nil {
|
||
|
|
log.Error("s.dao.DelChannelArc(%d,%d) error(%v)", mid, aid, err)
|
||
|
|
return
|
||
|
|
} else if affected > 0 {
|
||
|
|
s.dao.DelChannelArcCache(c, mid, cid, aid)
|
||
|
|
s.setChannelArcSortCache(c, mid, cid)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SortChannelArc sort channel archive.
|
||
|
|
func (s *Service) SortChannelArc(c context.Context, mid, cid, aid int64, orderNum int) (err error) {
|
||
|
|
var (
|
||
|
|
videos []*model.ChannelArc
|
||
|
|
bfSortBegin, bfSortEnd, chSort, afSort []*model.ChannelArcSort
|
||
|
|
affected int64
|
||
|
|
aidIndex, aidOn int
|
||
|
|
aidCheck bool
|
||
|
|
ts = time.Now()
|
||
|
|
)
|
||
|
|
if videos, err = s.dao.ChannelVideos(c, mid, cid, false); err != nil {
|
||
|
|
log.Error("s.dao.ChannelVideos(%d,%d) error(%v)", mid, cid, err)
|
||
|
|
return
|
||
|
|
} else if len(videos) == 0 {
|
||
|
|
err = ecode.ChNoArcs
|
||
|
|
return
|
||
|
|
} else {
|
||
|
|
videoLen := len(videos)
|
||
|
|
if orderNum > videoLen {
|
||
|
|
err = ecode.RequestErr
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for index, video := range videos {
|
||
|
|
if aid == video.Aid {
|
||
|
|
aidCheck = true
|
||
|
|
aidIndex = index
|
||
|
|
aidOn = video.OrderNum
|
||
|
|
break
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if !aidCheck {
|
||
|
|
err = ecode.RequestErr
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if orderNum > aidOn {
|
||
|
|
chSort = append(chSort, &model.ChannelArcSort{Aid: aid, OrderNum: orderNum})
|
||
|
|
for i, v := range videos {
|
||
|
|
if i < videoLen-orderNum {
|
||
|
|
bfSortBegin = append(bfSortBegin, &model.ChannelArcSort{Aid: v.Aid, OrderNum: v.OrderNum})
|
||
|
|
} else if i >= videoLen-orderNum && i < aidIndex {
|
||
|
|
chSort = append(chSort, &model.ChannelArcSort{Aid: v.Aid, OrderNum: v.OrderNum - 1})
|
||
|
|
} else if i > aidIndex {
|
||
|
|
bfSortEnd = append(bfSortEnd, &model.ChannelArcSort{Aid: v.Aid, OrderNum: v.OrderNum})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if orderNum < aidOn {
|
||
|
|
for i, v := range videos {
|
||
|
|
if i < aidIndex {
|
||
|
|
bfSortBegin = append(bfSortBegin, &model.ChannelArcSort{Aid: v.Aid, OrderNum: v.OrderNum})
|
||
|
|
} else if i > aidIndex && i <= videoLen-orderNum {
|
||
|
|
chSort = append(chSort, &model.ChannelArcSort{Aid: v.Aid, OrderNum: v.OrderNum + 1})
|
||
|
|
} else if i > videoLen-orderNum {
|
||
|
|
bfSortEnd = append(bfSortEnd, &model.ChannelArcSort{Aid: v.Aid, OrderNum: v.OrderNum})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
chSort = append(chSort, &model.ChannelArcSort{Aid: aid, OrderNum: orderNum})
|
||
|
|
} else {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
afSort = append(afSort, bfSortBegin...)
|
||
|
|
afSort = append(afSort, chSort...)
|
||
|
|
afSort = append(afSort, bfSortEnd...)
|
||
|
|
}
|
||
|
|
if affected, err = s.dao.EditChannelArc(c, mid, cid, ts, chSort); err != nil {
|
||
|
|
log.Error("s.dao.s.dao.EditChannelArc(%d,%d,%d,%d) error(%v)", mid, cid, aid, orderNum, err)
|
||
|
|
return
|
||
|
|
} else if affected > 0 {
|
||
|
|
s.dao.SetChannelArcSortCache(c, mid, cid, afSort)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// ChannelVideos get channel and channel video info.
|
||
|
|
func (s *Service) ChannelVideos(c context.Context, mid, cid int64, pn, ps int, isGuest, order bool) (res *model.ChannelDetail, err error) {
|
||
|
|
var (
|
||
|
|
channel *model.Channel
|
||
|
|
start = (pn - 1) * ps
|
||
|
|
end = start + ps - 1
|
||
|
|
)
|
||
|
|
if channel, err = s.Channel(c, mid, cid); err != nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
res = &model.ChannelDetail{Channel: channel}
|
||
|
|
res.Archives, err = s.channelArc(c, mid, cid, start, end, isGuest, order)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *Service) channelVideos(c context.Context, mid, cid int64, start, end int, order bool) (res []*model.ChannelArc, err error) {
|
||
|
|
var (
|
||
|
|
videos []*model.ChannelArc
|
||
|
|
addCache = true
|
||
|
|
)
|
||
|
|
if res, err = s.dao.ChannelArcsCache(c, mid, cid, start, end, order); err != nil {
|
||
|
|
addCache = false
|
||
|
|
} else if len(res) > 0 {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if videos, err = s.dao.ChannelVideos(c, mid, cid, order); err != nil {
|
||
|
|
log.Error("s.dao.ChannelVideos(%d,%d) error(%v)", mid, cid, err)
|
||
|
|
return
|
||
|
|
} else if len(videos) > 0 {
|
||
|
|
if addCache {
|
||
|
|
s.cache.Do(c, func(c context.Context) {
|
||
|
|
s.dao.SetChannelArcsCache(c, mid, cid, videos)
|
||
|
|
s.setChannelArcSortCache(c, mid, cid)
|
||
|
|
})
|
||
|
|
}
|
||
|
|
length := len(videos)
|
||
|
|
if length < start {
|
||
|
|
res = make([]*model.ChannelArc, 0)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if length > end {
|
||
|
|
res = videos[start : end+1]
|
||
|
|
} else {
|
||
|
|
res = videos[start:]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// CheckChannelVideo check useless channel video.
|
||
|
|
func (s *Service) CheckChannelVideo(c context.Context, mid, cid int64) (err error) {
|
||
|
|
var (
|
||
|
|
videos []*model.ChannelArc
|
||
|
|
aids []int64
|
||
|
|
)
|
||
|
|
if videos, err = s.dao.ChannelVideos(c, mid, cid, false); err != nil {
|
||
|
|
log.Error("s.dao.channelVideos(%d,%d) error(%v)", mid, cid, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for _, v := range videos {
|
||
|
|
aids = append(aids, v.Aid)
|
||
|
|
}
|
||
|
|
err = s.arcsCheck(c, mid, aids)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *Service) channelArc(c context.Context, mid, cid int64, start, end int, isGuest, order bool) (res []*arcmdl.Arc, err error) {
|
||
|
|
var (
|
||
|
|
videoAids []*model.ChannelArc
|
||
|
|
archives map[int64]*arcmdl.Arc
|
||
|
|
aids []int64
|
||
|
|
)
|
||
|
|
if videoAids, err = s.channelVideos(c, mid, cid, start, end, order); err != nil {
|
||
|
|
log.Error("s.dao.ChannelVideos(%d,%d) error(%v)", mid, cid, err)
|
||
|
|
return
|
||
|
|
} else if len(videoAids) == 0 {
|
||
|
|
res = _emptyChArc
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for _, video := range videoAids {
|
||
|
|
aids = append(aids, video.Aid)
|
||
|
|
}
|
||
|
|
if archives, err = s.archives(c, aids); err != nil {
|
||
|
|
log.Error("s.arc.Archives3(%v) error(%v)", aids, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for _, video := range videoAids {
|
||
|
|
if arc, ok := archives[video.Aid]; ok {
|
||
|
|
if arc.IsNormal() {
|
||
|
|
if arc.Access >= 10000 {
|
||
|
|
arc.Stat.View = -1
|
||
|
|
}
|
||
|
|
res = append(res, arc)
|
||
|
|
} else {
|
||
|
|
res = append(res, &arcmdl.Arc{Aid: video.Aid, Title: arc.Title, Pic: arc.Pic, Stat: arc.Stat, PubDate: arc.PubDate, State: arc.State})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *Service) setChannelArcSortCache(c context.Context, mid, cid int64) (err error) {
|
||
|
|
var (
|
||
|
|
videos []*model.ChannelArc
|
||
|
|
sorts []*model.ChannelArcSort
|
||
|
|
)
|
||
|
|
if videos, err = s.dao.ChannelVideos(c, mid, cid, false); err != nil {
|
||
|
|
log.Error("s.dao.ChannelVideos(%d,%d) error(%v)", mid, cid, err)
|
||
|
|
return
|
||
|
|
} else if len(videos) == 0 {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for _, v := range videos {
|
||
|
|
sort := &model.ChannelArcSort{Aid: v.Aid, OrderNum: v.OrderNum}
|
||
|
|
sorts = append(sorts, sort)
|
||
|
|
}
|
||
|
|
return s.dao.SetChannelArcSortCache(c, mid, cid, sorts)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *Service) archives(c context.Context, aids []int64) (archives map[int64]*arcmdl.Arc, err error) {
|
||
|
|
var (
|
||
|
|
mutex = sync.Mutex{}
|
||
|
|
aidsLen = len(aids)
|
||
|
|
group, errCtx = errgroup.WithContext(c)
|
||
|
|
)
|
||
|
|
archives = make(map[int64]*arcmdl.Arc, aidsLen)
|
||
|
|
for i := 0; i < aidsLen; i += _aidBulkSize {
|
||
|
|
var partAids []int64
|
||
|
|
if i+_aidBulkSize > aidsLen {
|
||
|
|
partAids = aids[i:]
|
||
|
|
} else {
|
||
|
|
partAids = aids[i : i+_aidBulkSize]
|
||
|
|
}
|
||
|
|
group.Go(func() (err error) {
|
||
|
|
var arcs *arcmdl.ArcsReply
|
||
|
|
arg := &arcmdl.ArcsRequest{Aids: partAids}
|
||
|
|
if arcs, err = s.arcClient.Arcs(errCtx, arg); err != nil {
|
||
|
|
log.Error("s.arcClient.Arcs(%v) error(%v)", partAids, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
mutex.Lock()
|
||
|
|
for _, v := range arcs.Arcs {
|
||
|
|
archives[v.Aid] = v
|
||
|
|
}
|
||
|
|
mutex.Unlock()
|
||
|
|
return
|
||
|
|
})
|
||
|
|
}
|
||
|
|
err = group.Wait()
|
||
|
|
return
|
||
|
|
}
|