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.
713 lines
19 KiB
713 lines
19 KiB
package archive |
|
|
|
import ( |
|
"context" |
|
"encoding/json" |
|
"fmt" |
|
"go-common/app/interface/main/creative/model/activity" |
|
"go-common/app/interface/main/creative/model/appeal" |
|
"go-common/app/interface/main/creative/model/archive" |
|
"go-common/app/interface/main/creative/model/search" |
|
"go-common/app/interface/main/creative/model/tag" |
|
pubSvc "go-common/app/interface/main/creative/service" |
|
"go-common/app/service/main/archive/api" |
|
mdlarc "go-common/app/service/main/archive/model/archive" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
"go-common/library/sync/errgroup" |
|
xtime "go-common/library/time" |
|
"strings" |
|
"time" |
|
) |
|
|
|
// SimpleArchiveVideos fn |
|
func (s *Service) SimpleArchiveVideos(c context.Context, mid, aid int64, ak, ck, ip string) (ap *archive.SimpleArchiveVideos, err error) { |
|
var ( |
|
sa *archive.SpArchive |
|
svs []*archive.SpVideo |
|
) |
|
// User identity && permission check, logic from project 'member' |
|
card, err := s.acc.Card(c, mid, ip) |
|
if err != nil { |
|
log.Error("s.acc.Profile(%d,%s) error(%v)", mid, ck, err) |
|
return |
|
} |
|
if sa, err = s.arc.SimpleArchive(c, aid, ip); err != nil { |
|
log.Error("s.arc.SimpleArchive(%d) error(%v)", aid, err) |
|
return |
|
} |
|
if sa == nil { |
|
log.Error("s.arc.SimpleArchive(%d) not found", aid) |
|
err = ecode.NothingFound |
|
return |
|
} |
|
if sa.Mid != mid { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
if svs, err = s.arc.SimpleVideos(c, aid, ip); err != nil { |
|
log.Error("s.arc.SimpleVideos(%d) error(%v)", aid, err) |
|
return |
|
} |
|
for index, sv := range svs { |
|
if sv.Status == -100 { |
|
sv.DmActive = 0 |
|
} else { |
|
sv.DmActive = 1 |
|
} |
|
svs[index] = sv |
|
} |
|
acceptAss := card.Rank > 15000 || card.Rank == 20000 |
|
ap = &archive.SimpleArchiveVideos{Archive: sa, SpVideos: svs, AcceptAss: acceptAss} |
|
return |
|
} |
|
|
|
// View get archive. |
|
func (s *Service) View(c context.Context, mid, aid int64, ip, platform string) (av *archive.ArcVideo, err error) { |
|
if av, err = s.arc.View(c, mid, aid, ip, archive.NeedPoi(platform), archive.NeedVote(platform)); err != nil { |
|
log.Error("s.arc.View(%d,%d) error(%v)", mid, aid, err) |
|
return |
|
} |
|
if av == nil || av.Archive == nil { |
|
log.Error("s.arc.View(%d) not found", mid) |
|
err = ecode.NothingFound |
|
return |
|
} |
|
av.Archive.NilPoiObj(platform) |
|
av.Archive.NilVote() |
|
// check white |
|
isWhite := false |
|
for _, m := range s.c.Whitelist.ArcMids { |
|
if m == mid { |
|
isWhite = true |
|
break |
|
} |
|
} |
|
if !isWhite { |
|
if av.Archive.Mid != mid { |
|
err = ecode.AccessDenied |
|
return |
|
} |
|
} |
|
var ( |
|
a = av.Archive |
|
vs = av.Videos |
|
) |
|
// add reject reason |
|
if (a.State == mdlarc.StateForbidRecicle || a.State == mdlarc.StateForbidLock) && a.RejectReason == "" { |
|
var c = 0 |
|
for _, v := range vs { |
|
if v.Status == mdlarc.StateForbidRecicle || |
|
v.Status == mdlarc.StateForbidLock || |
|
v.Status == mdlarc.StateForbidXcodeFail { |
|
c++ |
|
} |
|
} |
|
a.RejectReason = fmt.Sprintf("稿件中发现%d个问题。", c) |
|
} |
|
a.Cover = pubSvc.CoverURL(a.Cover) |
|
if a.OrderID != 0 { |
|
if a.OrderID, a.OrderName, _, err = s.order.OrderByAid(c, aid); err != nil { |
|
log.Error("s.order.OrderByAid(%d,%d) error(%v)", mid, aid, err) |
|
err = nil |
|
} |
|
} |
|
if a.MissionID > 0 { |
|
var act *activity.Activity |
|
if act, err = s.act.Subject(c, a.MissionID); err != nil { |
|
log.Error("s.act.Subject a.MissionID(%d) error(%v)", a.MissionID, err) |
|
err = nil |
|
return |
|
} |
|
a.MissionName = act.Name |
|
} |
|
if a.Porder != nil && a.Porder.Official == 1 && a.Porder.IndustryID == 1 { |
|
if v, ok := s.gameMap[a.Porder.BrandID]; ok { |
|
a.Porder.BrandName = v.GameName |
|
} |
|
} |
|
if a.UgcPay == 1 { |
|
a.UgcPayInfo = s.p.FillPayInfo(c, a, s.c.UgcPay, ip) |
|
} |
|
return |
|
} |
|
|
|
// Del fn |
|
// 1,unbind act;2,decrease coin;3,unbind order;4,clean memcache |
|
func (s *Service) Del(c context.Context, mid, aid int64, ip string) (err error) { |
|
av, err := s.View(c, mid, aid, ip, archive.PlatformWeb) |
|
if err != nil { |
|
return |
|
} |
|
if av == nil || av.Archive == nil { |
|
log.Error("s.arc.Del NothingFound (%d,%d,%d) error(%v)", mid, av.Archive.Mid, aid, err) |
|
err = ecode.NothingFound |
|
return |
|
} |
|
if av.Archive.Mid != mid { |
|
log.Error("s.arc.Del AccessDenied (%d,%d,%d) error(%v)", mid, av.Archive.Mid, aid, err) |
|
err = ecode.AccessDenied |
|
return |
|
} |
|
if av.Archive.UgcPay == 1 { |
|
canDelTime := xtime.Time(av.Archive.PTime.Time().AddDate(0, 0, s.c.UgcPay.AllowDeleteDays).Unix()) |
|
if av.Archive.CTime != av.Archive.PTime && xtime.Time(time.Now().Unix()) < canDelTime { |
|
log.Error("checkEditPay CreativePayForbidDeleteAfterOpen aid(%d) ctime(%v) ptime(%v)", av.Archive.Aid, av.Archive.CTime, av.Archive.PTime) |
|
err = ecode.CreativePayForbidDeleteAfterOpen |
|
return |
|
} |
|
} |
|
if err = s.arc.Del(c, mid, aid, ip); err != nil { |
|
log.Error("s.arc.Del(%d,%d) error(%v)", mid, aid, err) |
|
return |
|
} |
|
var ( |
|
a = av.Archive |
|
g = &errgroup.Group{} |
|
ctx = context.TODO() |
|
) |
|
g.Go(func() error { |
|
if e := s.act.Unbind(ctx, aid, a.MissionID, ip); e != nil { |
|
log.Error("s.act.UpdateByAid(%d,%d) error(%v)", aid, a.MissionID, e) |
|
} |
|
return nil |
|
}) |
|
g.Go(func() error { |
|
var coins float64 |
|
if a.State >= 0 { |
|
coins = -2 |
|
} else { |
|
coins = -1 |
|
} |
|
if e := s.coin.AddCoin(ctx, mid, aid, coins, ip); e != nil { |
|
log.Error("s.coin.AddCoin(%d,%d,%f,%s) error(%v)", mid, aid, coins, ip, e) |
|
} |
|
return nil |
|
}) |
|
g.Go(func() error { |
|
if e := s.order.Unbind(ctx, mid, aid, ip); e != nil { |
|
log.Error("s.order.Unbind(%d,%d,%s) error(%v)", mid, aid, ip, e) |
|
} |
|
return nil |
|
}) |
|
g.Go(func() error { |
|
if e := s.arc.DelSubmitCache(ctx, mid, a.Title); e != nil { |
|
log.Error("s.arc.DelSubmitCache (%d,%s,%s) error(%v)", mid, a.Title, ip, e) |
|
} |
|
return nil |
|
}) |
|
g.Wait() |
|
s.prom.Incr("archive_del") |
|
return |
|
} |
|
|
|
// Archives for app all achives. |
|
func (s *Service) Archives(c context.Context, mid int64, tid int16, kw, order, class, ip string, pn, ps, coop int) (res *search.Result, err error) { |
|
if res, err = s.Search(c, mid, tid, kw, order, class, ip, pn, ps, coop); err != nil { |
|
log.Error("s.Search err(%v)", err) |
|
return |
|
} |
|
if res == nil || res.Archives == nil || len(res.Archives) == 0 { |
|
return |
|
} |
|
for _, av := range res.Archives { |
|
a := &api.Arc{ |
|
Aid: av.Archive.Aid, |
|
TypeID: int32(av.Archive.TypeID), |
|
TypeName: av.TypeName, |
|
Copyright: int32(av.Archive.Copyright), |
|
Title: av.Archive.Title, |
|
Desc: av.Archive.Desc, |
|
Attribute: av.Archive.Attribute, |
|
Videos: int64(len(av.Videos)), |
|
Pic: pubSvc.CoverURL(av.Archive.Cover), |
|
State: int32(av.Archive.State), |
|
Access: int32(av.Archive.Access), |
|
Tags: strings.Split(av.Archive.Tag, ","), |
|
Duration: av.Archive.Duration, |
|
MissionID: av.Archive.MissionID, |
|
OrderID: av.Archive.OrderID, |
|
PubDate: av.Archive.PTime, |
|
Ctime: av.Archive.CTime, |
|
} |
|
a.Author = api.Author{ |
|
Mid: av.Archive.Mid, |
|
Name: av.Archive.Author, |
|
} |
|
a.Stat = api.Stat{ |
|
Aid: av.Stat.Aid, |
|
View: int32(av.Stat.View), |
|
Danmaku: int32(av.Stat.Danmaku), |
|
Reply: int32(av.Stat.Reply), |
|
Fav: int32(av.Stat.Fav), |
|
Coin: int32(av.Stat.Coin), |
|
Share: int32(av.Stat.Share), |
|
NowRank: int32(av.Stat.NowRank), |
|
HisRank: int32(av.Stat.HisRank), |
|
} |
|
ava := &archive.OldArchiveVideoAudit{ |
|
Arc: a, |
|
StatePanel: av.StatePanel, |
|
ParentTName: av.ParentTName, |
|
Dtime: av.Archive.DTime, |
|
StateDesc: av.Archive.StateDesc, |
|
RejectReson: av.Archive.RejectReason, |
|
UgcPay: av.Archive.UgcPay, |
|
Attrs: av.Archive.Attrs, |
|
} |
|
if len(av.ArcVideo.Videos) > 0 { |
|
var vas = make([]*archive.OldVideoAudit, 0, len(av.ArcVideo.Videos)) |
|
for _, vd := range av.ArcVideo.Videos { |
|
va := &archive.OldVideoAudit{ |
|
IndexOrder: vd.Index, |
|
Eptitle: vd.Title, |
|
Reason: vd.RejectReason, |
|
} |
|
ava.VideoAudits = append(vas, va) |
|
} |
|
} |
|
res.OldArchives = append(res.OldArchives, ava) |
|
} |
|
return |
|
} |
|
|
|
// Search all achive. |
|
func (s *Service) Search(c context.Context, mid int64, tid int16, keyword, order, class, ip string, pn, ps, coop int) (res *search.Result, err error) { |
|
defer func() { |
|
if res != nil { |
|
// get pending apply num |
|
if coop > 0 { |
|
count, _ := s.arc.CountByMID(c, mid) |
|
res.Applies = &search.ApplyStateCount{ |
|
Pending: count, |
|
} |
|
} |
|
} |
|
}() |
|
if res, err = s.sear.ArchivesES(c, mid, tid, keyword, order, class, ip, pn, ps, coop); err != nil { |
|
// search err, use archive-service |
|
log.Error("s.arc.Search(%d) error(%v)", mid, err) |
|
res, err = s.ArchivesFromService(c, mid, class, ip, pn, ps) |
|
if err != nil { |
|
return |
|
} |
|
} |
|
// add arctype *must return |
|
res.ArrType = []*search.TypeCount{} |
|
for _, v := range s.p.TopTypesCache { |
|
t := &search.TypeCount{ |
|
Tid: v.ID, |
|
Name: v.Name, |
|
} |
|
if _, ok := res.Type[v.ID]; ok { |
|
t.Count = res.Type[v.ID].Count |
|
} |
|
res.ArrType = append(res.ArrType, t) |
|
} |
|
if res == nil || len(res.Aids) == 0 { |
|
return |
|
} |
|
avm, err := s.arc.Views(c, mid, res.Aids, ip) |
|
if err != nil { |
|
log.Error("s.arc.Views res.Aids(%v), ip(%s) err(%v)", res.Aids, ip, err) |
|
return |
|
} |
|
// get arc stats |
|
as, _ := s.arc.Stats(c, res.Aids, ip) |
|
// archives |
|
for _, aid := range res.Aids { |
|
av := avm[aid] |
|
if av == nil { |
|
continue |
|
} |
|
a := av.Archive |
|
a.Cover = pubSvc.CoverURL(a.Cover) |
|
ava := &archive.ArcVideoAudit{ArcVideo: av} |
|
// arc stat info |
|
if _, ok := as[aid]; ok { |
|
ava.Stat = as[aid] |
|
} else { |
|
ava.Stat = &api.Stat{} |
|
} |
|
// typename |
|
if _, ok := s.p.TypeMapCache[a.TypeID]; ok { |
|
ava.TypeName = s.p.TypeMapCache[a.TypeID].Name |
|
} |
|
// parent typename |
|
if _, ok := s.p.TypeMapCache[a.TypeID]; ok { |
|
if _, ok := s.p.TypeMapCache[s.p.TypeMapCache[a.TypeID].Parent]; ok { |
|
ava.ParentTName = s.p.TypeMapCache[s.p.TypeMapCache[a.TypeID].Parent].Name |
|
} |
|
} |
|
// state panel |
|
ava.StatePanel = archive.StatePanel(a.State) |
|
// state desc |
|
ava.Archive.StateDesc = s.c.StatDesc(int(a.State)) |
|
// not pubbed videos for reason |
|
unpubedVideos := make([]*archive.Video, 0, len(ava.Videos)) |
|
for _, v := range ava.Videos { |
|
if v.Status == -2 || v.Status == -4 || v.Status == -16 { |
|
unpubedVideos = append(unpubedVideos, v) |
|
} |
|
} |
|
c := len(unpubedVideos) |
|
if c > 0 { |
|
a.RejectReason = fmt.Sprintf("稿件中发现%d个问题。", c) |
|
} |
|
// set attrs |
|
attrs := &archive.Attrs{ |
|
IsCoop: int8(ava.AttrVal(archive.AttrBitIsCoop)), |
|
IsOwner: ava.IsOwner(mid), |
|
} |
|
ava.Archive.Attrs = attrs |
|
ava.Videos = unpubedVideos |
|
res.Archives = append(res.Archives, ava) |
|
} |
|
return |
|
} |
|
|
|
// ApplySearch all achive. |
|
func (s *Service) ApplySearch(c context.Context, mid int64, tid int16, keyword, state string, pn, ps int) (res *search.StaffApplyResult, err error) { |
|
var mids []int64 |
|
if res, err = s.sear.ArchivesStaffES(c, mid, tid, keyword, state, pn, ps); err != nil { |
|
log.Error("s.arc.ArchivesStaffES(%d) error(%v)", mid, err) |
|
return |
|
} |
|
// add arctype *must return |
|
res.ArrType = []*search.TypeCount{} |
|
for _, v := range s.p.TopTypesCache { |
|
t := &search.TypeCount{ |
|
Tid: v.ID, |
|
Name: v.Name, |
|
} |
|
if _, ok := res.Type[v.ID]; ok { |
|
t.Count = res.Type[v.ID].Count |
|
} |
|
res.ArrType = append(res.ArrType, t) |
|
} |
|
if res == nil || len(res.Aids) == 0 { |
|
return |
|
} |
|
// get archives |
|
avm, err := s.arc.Views(c, mid, res.Aids, "") |
|
if err != nil { |
|
log.Error("s.arc.Views res.Aids(%v), ip(%s) err(%v)", res.Aids, err) |
|
return |
|
} |
|
// get applies |
|
apm := make(map[int64]*archive.StaffApply) |
|
applies, err := s.arc.StaffApplies(c, mid, res.Aids) |
|
for _, ap := range applies { |
|
apm[ap.ApplyAID] = ap |
|
} |
|
// combine |
|
for _, aid := range res.Aids { |
|
av := avm[aid] |
|
if av == nil { |
|
continue |
|
} |
|
a := av.Archive |
|
a.Cover = pubSvc.CoverURL(a.Cover) |
|
ava := &archive.ArcVideoAudit{ArcVideo: av} |
|
// typename |
|
if _, ok := s.p.TypeMapCache[a.TypeID]; ok { |
|
ava.TypeName = s.p.TypeMapCache[a.TypeID].Name |
|
} |
|
// parent typename |
|
if _, ok := s.p.TypeMapCache[a.TypeID]; ok { |
|
if _, ok := s.p.TypeMapCache[s.p.TypeMapCache[a.TypeID].Parent]; ok { |
|
ava.ParentTName = s.p.TypeMapCache[s.p.TypeMapCache[a.TypeID].Parent].Name |
|
} |
|
} |
|
// state panel |
|
ava.StatePanel = archive.StatePanel(a.State) |
|
// state desc |
|
ava.Archive.StateDesc = s.c.StatDesc(int(a.State)) |
|
// not pubbed videos for reason |
|
unpubedVideos := make([]*archive.Video, 0, len(ava.Videos)) |
|
for _, v := range ava.Videos { |
|
if v.Status == -2 || v.Status == -4 || v.Status == -16 { |
|
unpubedVideos = append(unpubedVideos, v) |
|
} |
|
} |
|
c := len(unpubedVideos) |
|
if c > 0 { |
|
a.RejectReason = fmt.Sprintf("稿件中发现%d个问题。", c) |
|
} |
|
ava.Videos = unpubedVideos |
|
// get apply |
|
apply := &search.StaffApply{} |
|
if v, ok := apm[aid]; ok { |
|
apply.ID = v.ID |
|
apply.Type = v.Type |
|
apply.Mid = v.ApplyUpMID |
|
apply.State = v.StaffState |
|
apply.ApplyState = v.State |
|
apply.ApplyTitle = v.ApplyTitle |
|
} |
|
// set archive |
|
apply.Archive = ava |
|
mids = append(mids, apply.Mid) |
|
res.Applies = append(res.Applies, apply) |
|
} |
|
// get name |
|
users, _ := s.acc.Infos(c, mids, "") |
|
for _, v := range res.Applies { |
|
if u, ok := users[v.Mid]; ok { |
|
v.Uname = u.Name |
|
} |
|
} |
|
return |
|
} |
|
|
|
// Types get typelist. |
|
func (s *Service) Types(c context.Context, lang string) (tps []*archive.Type) { |
|
if _, ok := s.p.TypesCache[lang]; !ok { |
|
lang = "ch" |
|
} |
|
tps = s.p.TypesCache[lang] |
|
return |
|
} |
|
|
|
// StaffTitles get staff titles. |
|
func (s *Service) StaffTitles(c context.Context) (titles []*tag.StaffTitle) { |
|
return s.p.StaffTitlesCache |
|
} |
|
|
|
// AppTypes fn |
|
func (s *Service) AppTypes(c context.Context, lang string) (tps []*archive.Type) { |
|
if _, ok := s.p.CTypesCache[lang]; !ok { |
|
lang = "ch" |
|
} |
|
tps = s.p.CTypesCache[lang] |
|
for _, val := range tps { |
|
for _, child := range val.Children { |
|
child.Notice = child.AppNotice |
|
} |
|
} |
|
return |
|
} |
|
|
|
// Activities get activity list. |
|
func (s *Service) Activities(c context.Context) (acts []*activity.Activity) { |
|
acts = s.p.ActVideoAllCache |
|
return |
|
} |
|
|
|
// WebArchives achive list with appeal. |
|
func (s *Service) WebArchives(c context.Context, mid int64, tid int16, keyword, order, class, ip string, pn, ps, coop int) (res *search.Result, err error) { |
|
if res, err = s.Search(c, mid, tid, keyword, order, class, ip, pn, ps, coop); err != nil { |
|
log.Error("s.Search err(%v)", err) |
|
return |
|
} |
|
if res == nil || len(res.Aids) == 0 { |
|
return |
|
} |
|
//做降级 |
|
aps, err := s.ap.AppealList(c, mid, appeal.Business, ip) |
|
if err != nil { |
|
log.Error("s.ap.AppealList error(%v)", err) |
|
err = nil |
|
} |
|
if len(aps) == 0 { |
|
return |
|
} |
|
aaMap := make(map[int64]int64, len(aps)) |
|
for _, v := range aps { |
|
if appeal.IsOpen(v.BusinessState) { |
|
aaMap[v.Oid] = v.ID |
|
} |
|
} |
|
for _, v := range res.Archives { |
|
v.OpenAppeal = aaMap[v.Archive.Aid] |
|
} |
|
return |
|
} |
|
|
|
// Videos get Simple Archive and Videos Info. |
|
func (s *Service) Videos(c context.Context, mid, aid int64, ip string) (sa archive.SimpleArchive, svs []*archive.SimpleVideo, err error) { |
|
var av *archive.ArcVideo |
|
if av, err = s.arc.View(c, mid, aid, ip, 0, 0); err != nil { |
|
log.Error("s.arc.View(%d,%d) error(%v)", mid, aid, err) |
|
return |
|
} |
|
if av == nil { |
|
log.Error("s.arc.View(%d) not found", mid) |
|
err = ecode.RequestErr |
|
return |
|
} |
|
// white list check |
|
isWhite := false |
|
for _, m := range s.c.Whitelist.DataMids { |
|
if m == mid { |
|
isWhite = true |
|
break |
|
} |
|
} |
|
var ( |
|
a = av.Archive |
|
vs = av.Videos |
|
) |
|
if !isWhite { |
|
if a.Mid != mid { |
|
err = ecode.AccessDenied |
|
return |
|
} |
|
} |
|
sa.Aid = a.Aid |
|
sa.Title = a.Title |
|
for _, v := range vs { |
|
svs = append(svs, &archive.SimpleVideo{ |
|
Cid: v.Cid, |
|
Title: v.Title, |
|
Index: v.Index, |
|
}) |
|
} |
|
return |
|
} |
|
|
|
// ArchivesFromService get archives from service |
|
func (s *Service) ArchivesFromService(c context.Context, mid int64, class, ip string, pn, ps int) (sres *search.Result, err error) { |
|
aids, count, err := s.arc.UpArchives(c, mid, int64(pn), int64(ps), 0, ip) |
|
if err != nil { |
|
return |
|
} |
|
sres = &search.Result{} |
|
sres.Aids = aids |
|
sres.Page.Pn = pn |
|
sres.Page.Ps = ps |
|
sres.Page.Count = int(count) |
|
return |
|
} |
|
|
|
// DescFormat get desc format |
|
func (s *Service) DescFormat(c context.Context, typeid, copyright int64, langStr, ip string) (desc *archive.DescFormat, err error) { |
|
lang := archive.ToLang(langStr) |
|
desc, ok := s.p.DescFmtsCache[typeid][int8(copyright)][lang] |
|
if !ok { |
|
err = nil |
|
} |
|
if desc != nil { |
|
var Components []*struct { |
|
Name interface{} |
|
} |
|
if err = json.Unmarshal([]byte(desc.Components), &Components); err != nil || len(Components) == 0 { |
|
desc = nil |
|
err = nil |
|
} |
|
} |
|
return |
|
} |
|
|
|
// AppFormats for app portal list. |
|
func (s *Service) AppFormats(c context.Context) (af []*archive.AppFormat, err error) { |
|
for _, f := range s.p.DescFmtsArrCache { |
|
format := &archive.AppFormat{ID: f.ID, Copyright: f.Copyright, TypeID: f.TypeID} |
|
af = append(af, format) |
|
} |
|
return |
|
} |
|
|
|
// Video get video by aid and cid |
|
func (s *Service) Video(c context.Context, mid, aid, cid int64, ip string) (video *api.Page, err error) { |
|
if video, err = s.arc.Video(c, aid, cid, ip); err != nil { |
|
log.Error("s.arc.Video %d,%d,%s | err(%v)", aid, cid, ip, err) |
|
} |
|
return |
|
} |
|
|
|
// VideoJam get video traffic jam level from service |
|
// level为0的时候，可以忽略错误处理，映射表里已经做了前端容错 |
|
func (s *Service) VideoJam(c context.Context, ip string) (j *archive.VideoJam, err error) { |
|
level, _ := s.arc.VideoJam(c, ip) |
|
if jam, ok := archive.VjInfo[level]; ok { |
|
j = jam |
|
} else { |
|
j = archive.VjInfo[0] |
|
} |
|
return |
|
} |
|
|
|
// DescFormatForApp get desc format length |
|
func (s *Service) DescFormatForApp(c context.Context, typeid, copyright int64, langStr, ip string) (desc *archive.DescFormat, length int, err error) { |
|
var ( |
|
descLengthMax = 2000 |
|
descLengthMin = 250 |
|
ok bool |
|
) |
|
lang := archive.ToLang("") |
|
if desc, ok = s.p.DescFmtsCache[typeid][int8(copyright)][lang]; !ok { |
|
err = nil |
|
} |
|
if typeid == 0 { |
|
length = descLengthMin |
|
} else if desc != nil { |
|
length = descLengthMax |
|
} else { |
|
length = descLengthMin |
|
} |
|
return |
|
} |
|
|
|
// Dpub for app view. |
|
func (s *Service) Dpub() (dpub *archive.Dpub) { |
|
now := time.Now() |
|
dpub = &archive.Dpub{ |
|
Deftime: xtime.Time(now.Add(time.Duration(14400) * time.Second).Unix()), |
|
DeftimeEnd: xtime.Time(now.Add(time.Duration(15*24) * time.Hour).Unix()), |
|
DeftimeMsg: ecode.String(ecode.VideoupDelayTimeErr.Error()).Message(), |
|
} |
|
return |
|
} |
|
|
|
// SimpleArcVideos fn |
|
func (s *Service) SimpleArcVideos(c context.Context, mid int64, tid int16, kw, order, class, ip string, pn, ps, coop int) (res *search.SimpleResult, err error) { |
|
var sres *search.Result |
|
res = &search.SimpleResult{} |
|
if sres, err = s.sear.ArchivesES(c, mid, tid, kw, order, class, ip, pn, ps, coop); err != nil { |
|
log.Error("s.arc.Search mid(%d)|error(%v)", mid, err) |
|
sres, err = s.ArchivesFromService(c, mid, class, ip, pn, ps) // search err, use archive-service |
|
if err != nil { |
|
log.Error("s.ArchivesFromService mid(%d)|error(%v)", mid, err) |
|
return |
|
} |
|
} |
|
if sres == nil || len(sres.Aids) == 0 { |
|
return |
|
} |
|
res.Class = sres.Class |
|
res.Page = sres.Page |
|
avm, err := s.arc.Views(c, mid, sres.Aids, ip) |
|
if err != nil { |
|
log.Error("s.arc.Views mid(%d)|aids(%v)|ip(%s)|err(%v)", mid, sres.Aids, ip, err) |
|
return |
|
} |
|
savs := make([]*search.SimpleArcVideos, 0, len(avm)) |
|
for _, aid := range sres.Aids { |
|
av, ok := avm[aid] |
|
if !ok || av == nil || av.Archive == nil { |
|
continue |
|
} |
|
vds := make([]*archive.SimpleVideo, 0, len(av.Videos)) |
|
for _, v := range av.Videos { |
|
if v == nil { |
|
continue |
|
} |
|
vd := &archive.SimpleVideo{ |
|
Cid: v.Cid, |
|
Title: v.Title, |
|
Index: v.Index, |
|
} |
|
vds = append(vds, vd) |
|
} |
|
sav := &search.SimpleArcVideos{} |
|
sav.Archive = &archive.SimpleArchive{ |
|
Aid: av.Archive.Aid, |
|
Title: av.Archive.Title, |
|
} |
|
sav.Videos = vds |
|
savs = append(savs, sav) |
|
} |
|
res.ArchivesVideos = savs |
|
return |
|
}
|
|
|