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.
122 lines
3.3 KiB
122 lines
3.3 KiB
package service |
|
|
|
import ( |
|
"context" |
|
"fmt" |
|
|
|
"go-common/app/interface/main/dm2/model" |
|
"go-common/library/log" |
|
) |
|
|
|
func keySubtitleSingle(oid int64, tp int32) string { |
|
return fmt.Sprintf("subtitle_%d_%d", oid, tp) |
|
} |
|
|
|
// GetWebVideoSubtitle . |
|
func (s *Service) GetWebVideoSubtitle(c context.Context, aid, oid int64, tp int32) (res *model.VideoSubtitles, err error) { |
|
var ( |
|
subtitles []*model.VideoSubtitle |
|
subtitleSubject *model.SubtitleSubject |
|
allowSubmit bool |
|
closed bool |
|
lan, lanDoc string |
|
) |
|
if subtitleSubject, err = s.subtitleSubject(c, aid); err != nil { |
|
log.Error("params(aid:%v).err(%v)", aid, err) |
|
err = nil |
|
} |
|
if subtitleSubject != nil { |
|
allowSubmit = subtitleSubject.Allow |
|
closed = subtitleSubject.AttrVal(model.AttrSubtitleClose) == model.AttrYes |
|
lan, lanDoc = s.subtitleLans.GetByID(int64(subtitleSubject.Lan)) |
|
} |
|
res = &model.VideoSubtitles{ |
|
AllowSubmit: allowSubmit, |
|
Lan: lan, |
|
LanDoc: lanDoc, |
|
} |
|
if closed { |
|
res.AllowSubmit = false |
|
return |
|
} |
|
if subtitles, err = s.getVideoSubtitles(c, oid, tp); err != nil { |
|
return |
|
} |
|
res.Subtitles = subtitles |
|
return |
|
} |
|
|
|
// singleGetVideoSubtitle use singleflight, but not cache sub item |
|
func (s *Service) singleGetVideoSubtitle(c context.Context, oid int64, tp int32) (res []*model.VideoSubtitle, err error) { |
|
var ( |
|
v interface{} |
|
subtitleIds []int64 |
|
subtitles map[int64]*model.Subtitle |
|
) |
|
v, err, _ = s.subtitleSingleGroup.Do(keySubtitleSingle(oid, tp), func() (reply interface{}, err error) { |
|
if subtitleIds, err = s.dao.GetSubtitleIds(c, oid, tp); err != nil { |
|
log.Error("params(oid:%v, tp:%v).err(%v)", oid, tp, err) |
|
return |
|
} |
|
if len(subtitleIds) == 0 { |
|
return |
|
} |
|
if subtitles, err = s.getSubtitles(c, oid, subtitleIds); err != nil { |
|
log.Error("params(oid:%v, subtitleIds:%v).err(%v)", oid, subtitleIds, err) |
|
return |
|
} |
|
result := make([]*model.VideoSubtitle, 0, len(subtitles)) |
|
for _, subtitle := range subtitles { |
|
lan, lanDoc := s.subtitleLans.GetByID(int64(subtitle.Lan)) |
|
vs := &model.VideoSubtitle{ |
|
ID: subtitle.ID, |
|
IsLock: subtitle.IsLock, |
|
Lan: lan, |
|
LanDoc: lanDoc, |
|
SubtitleURL: subtitle.SubtitleURL, |
|
} |
|
if subtitle.IsSign { |
|
vs.AuthorMid = subtitle.AuthorID |
|
} |
|
result = append(result, vs) |
|
} |
|
reply = result |
|
return |
|
}) |
|
if err != nil { |
|
log.Error("params(oid:%v, tp:%v).err(%v)", oid, tp, err) |
|
return |
|
} |
|
res, _ = v.([]*model.VideoSubtitle) |
|
return |
|
} |
|
|
|
// getVideoSubtitles get from cache |
|
func (s *Service) getVideoSubtitles(c context.Context, oid int64, tp int32) (subtitles []*model.VideoSubtitle, err error) { |
|
var ( |
|
cacheErr bool |
|
videoSubtitleCache *model.VideoSubtitleCache |
|
) |
|
if videoSubtitleCache, err = s.dao.VideoSubtitleCache(c, oid, tp); err != nil { |
|
cacheErr = true |
|
err = nil |
|
} |
|
if videoSubtitleCache != nil { |
|
subtitles = videoSubtitleCache.VideoSubtitles |
|
return |
|
} |
|
if subtitles, err = s.singleGetVideoSubtitle(c, oid, tp); err != nil { |
|
log.Error("params(oid:%v,tp:%v).err(%v)", oid, tp, err) |
|
return |
|
} |
|
videoSubtitleCache = &model.VideoSubtitleCache{ |
|
VideoSubtitles: subtitles, |
|
} |
|
if !cacheErr { |
|
temp := videoSubtitleCache |
|
s.cache.Do(c, func(ctx context.Context) { |
|
s.dao.SetVideoSubtitleCache(ctx, oid, tp, temp) |
|
}) |
|
} |
|
return |
|
}
|
|
|