Create & Init Project...

app/interface/main/tv/service/view/BUILD

@@ -0,0 +1,52 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "access.go",
+        "auth.go",
+        "contain.go",
+        "empty_arc.go",
+        "service.go",
+        "view.go",
+    ],
+    importpath = "go-common/app/interface/main/tv/service/view",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/tv/conf:go_default_library",
+        "//app/interface/main/tv/dao/account:go_default_library",
+        "//app/interface/main/tv/dao/archive:go_default_library",
+        "//app/interface/main/tv/dao/cms:go_default_library",
+        "//app/interface/main/tv/dao/favorite:go_default_library",
+        "//app/interface/main/tv/dao/upper:go_default_library",
+        "//app/interface/main/tv/model:go_default_library",
+        "//app/interface/main/tv/model/upper:go_default_library",
+        "//app/interface/main/tv/model/view:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/archive/model/archive:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/stat/prom:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/tv/service/view/access.go

@@ -0,0 +1,46 @@
+package view
+
+import (
+	"context"
+
+	"go-common/app/interface/main/tv/dao/account"
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// checkAceess check user Aceess
+func (s *Service) checkAceess(c context.Context, mid, aid int64, state, access int, ak, ip string) (err error) {
+	if state >= 0 && access == 0 {
+		return
+	}
+	if state < 0 {
+		if state == archive.StateForbidFixed {
+			log.Warn("archive(%d) is fixed", aid)
+		} else if state == archive.StateForbidUpDelete {
+			log.Warn("archive(%d) is deleted", aid)
+		} else {
+			log.Warn("mid(%d) have not access view not pass archive(%d) ", mid, aid)
+		}
+		err = ecode.NothingFound
+		return
+	}
+	if mid == 0 {
+		log.Warn("not login can not view(%d) state(%d) access(%d) mid(%d)", aid, state, access, mid)
+		err = ecode.AccessDenied
+		s.prom.Incr("no_login_access")
+		return
+	}
+	card, err := s.accDao.Card3(c, mid)
+	if err != nil {
+		log.Warn("s.accDao.Info failed can not view(%d) state(%d) access(%d)", aid, state, access)
+		s.prom.Incr("err_login_access")
+		return
+	}
+	if access > 0 && int(card.Rank) < access && !account.IsVip(card) {
+		err = ecode.AccessDenied
+		log.Warn("mid(%d) rank(%d) vip(tp:%d,status:%d) have not access(%d) view archive(%d) ", mid, card.Rank, card.Vip.Type, card.Vip.Status, access, aid)
+		s.prom.Incr("login_access")
+	}
+	return
+}

app/interface/main/tv/service/view/auth.go

@@ -0,0 +1,32 @@
+package view
+
+import (
+	"context"
+
+	"go-common/app/interface/main/tv/model"
+	"go-common/library/log"
+)
+
+// ArcMsg returns the arc auth msg
+func (s *Service) ArcMsg(aid int64) (arc *model.ArcCMS, ok bool, msg string, err error) {
+	if arc, err = s.cmsDao.LoadArcMeta(context.TODO(), aid); err != nil {
+		log.Error("ArcMsg loadArcMeta aid %d, Err %v", aid, err)
+		return
+	}
+	ok, msg = s.cmsDao.UgcErrMsg(arc.Deleted, arc.Result, arc.Valid)
+	return
+}
+
+// VideoMsg returns the arc auth msg
+func (s *Service) VideoMsg(ctx context.Context, cid int64) (ok bool, msg string, err error) {
+	var video *model.VideoCMS
+	if video, err = s.cmsDao.LoadVideoMeta(context.TODO(), cid); err != nil {
+		log.Error("VideoMsg LoadVideoMeta aid %d, Err %v", cid, err)
+		return
+	}
+	ok, msg = s.cmsDao.UgcErrMsg(video.Deleted, video.Result, video.Valid)
+	if ok { // if video is normal, we also need to check it's archive
+		_, ok, msg, err = s.ArcMsg(int64(video.AID))
+	}
+	return
+}

app/interface/main/tv/service/view/contain.go

@@ -0,0 +1,145 @@
+package view
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/tv/model"
+	"go-common/app/interface/main/tv/model/view"
+	arcwar "go-common/app/service/main/archive/api"
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/sync/errgroup"
+)
+
+var (
+	_rate = map[int]int64{15: 464, 16: 464, 32: 1028, 48: 1328, 64: 2192, 74: 3192, 80: 3192, 112: 6192, 116: 6192, 66: 1820}
+)
+
+func initPage(v *arcwar.Page, isBangumi bool) (page *view.Page) {
+	page = &view.Page{}
+	metas := make([]*view.Meta, 0, 4)
+	for q, r := range _rate {
+		meta := &view.Meta{
+			Quality: q,
+			Size:    int64(float64(r*v.Duration) * 1.1 / 8.0),
+		}
+		metas = append(metas, meta)
+	}
+	if isBangumi {
+		v.From = "bangumi"
+	}
+	page.Page = v
+	page.Metas = metas
+	return
+}
+
+func (s *Service) initPages(c context.Context, vs *view.Static, ap []*arcwar.Page) (err error) {
+	var (
+		cids      []int64
+		pages     = make([]*view.Page, 0, len(ap))
+		vsAuth    map[int64]*model.VideoCMS
+		isBangumi = vs.AttrVal(archive.AttrBitIsBangumi) == archive.AttrYes
+		emptyArc  = true
+	)
+	for _, v := range ap {
+		cids = append(cids, v.Cid)
+	}
+	if vsAuth, err = s.cmsDao.LoadVideosMeta(c, cids); err != nil {
+		log.Error("initPages LoadVideosMeta Cid %v, Err %v", cids, err)
+		return
+	}
+	for _, v := range ap {
+		if auth, ok := vsAuth[v.Cid]; ok { // auditing data can't show
+			if !auth.Auditing() {
+				pages = append(pages, initPage(v, isBangumi))
+			}
+			if auth.CanPlay() {
+				emptyArc = false
+			}
+		}
+	}
+	if emptyArc { // if the arc doesn't have any video that can play, we put its valid field to 0 in an asynchronous manner
+		log.Info("emptyArc add Aid %d, Cids %v", vs.Aid, cids)
+		s.emptyArcCh <- vs.Aid
+	}
+	if len(pages) == 0 {
+		err = ecode.TvAllDataAuditing
+		return
+	}
+	vs.Pages = pages
+	return
+}
+
+// initRelates init Relates
+func (s *Service) initRelates(c context.Context, v *view.View, ip string, now time.Time) {
+	var (
+		rls []*view.Relate
+		err error
+	)
+	if rls, err = s.dealRcmdRelate(ctx, v.Aid, ip); err != nil {
+		log.Error("initRelates For Aid %d, Error %v", v.Aid, err)
+		return
+	}
+	if len(rls) == 0 {
+		s.prom.Incr("zero_relates")
+		return
+	}
+	v.Relates = rls
+}
+
+func (s *Service) dealRcmdRelate(c context.Context, aid int64, ip string) (rls []*view.Relate, err error) {
+	if rls, err = s.arcDao.RelatesCache(c, aid); err != nil { // mc error
+		return
+	}
+	if len(rls) != 0 {
+		s.pHit.Incr("relate_cache")
+		return
+	}
+	var (
+		aids     []int64
+		as       map[int64]*arcwar.Arc
+		arcMetas map[int64]*model.ArcCMS
+	)
+	s.pMiss.Incr("relate_cache")
+	if aids, err = s.arcDao.RelateAids(c, aid, ip); err != nil { // backsource
+		return
+	}
+	if len(aids) == 0 {
+		return
+	}
+	g, errCtx := errgroup.WithContext(c)
+	g.Go(func() (err error) {
+		as, err = s.arcDao.Archives(errCtx, aids)
+		return
+	})
+	g.Go(func() (err error) {
+		arcMetas, err = s.cmsDao.LoadArcsMediaMap(errCtx, aids)
+		return
+	})
+	if err = g.Wait(); err != nil {
+		log.Error("dealRcmdRelate For Aid %d, Err %v", aid, err)
+		return
+	}
+	for _, aid := range aids {
+		if a, ok := as[aid]; ok {
+			// auth, filter can't play ones
+			if arcCMS, okCMS := arcMetas[aid]; !okCMS {
+				log.Error("LoadArcsMediaMap Missing Aid %d Info", aid)
+				continue
+			} else if canplay, _ := s.cmsDao.UgcErrMsg(arcCMS.Deleted, arcCMS.Result, arcCMS.Valid); !canplay {
+				log.Warn("LoadArcsMediaMap Aid %d Can't play, Struct %v", aid, arcCMS)
+				continue
+			}
+			// can play, init them
+			r := &view.Relate{}
+			r.FromAv(a, "")
+			rls = append(rls, r)
+		}
+	}
+	if len(rls) != 0 {
+		s.arcDao.AddRelatesCache(aid, rls)
+	}
+	return
+}

app/interface/main/tv/service/view/empty_arc.go

@@ -0,0 +1,40 @@
+package view
+
+import (
+	"time"
+
+	"go-common/library/log"
+)
+
+func (s *Service) emptyArcproc() {
+	var (
+		ps        = s.conf.Cfg.EmptyArc.UnshelvePS
+		emptyAids = make(map[int64]int, ps)
+	)
+	for {
+		aid, ok := <-s.emptyArcCh
+		if !ok {
+			log.Warn("[emptyArcproc] channel quit")
+			return
+		}
+		emptyAids[aid] = 1
+		if len(emptyAids) < ps { // not enough cid, stay waiting
+			time.Sleep(2 * time.Second)
+			continue
+		}
+		distinctAIDs := pickKeys(emptyAids)
+		emptyAids = make(map[int64]int, ps)
+		if err := s.cmsDao.UnshelveArcs(ctx, distinctAIDs); err != nil {
+			log.Error("emptyArc Aids %v, Err %v", distinctAIDs, err)
+			continue
+		}
+		log.Info("emptyArc Apply %d Aids: %v", len(distinctAIDs), distinctAIDs)
+	}
+}
+
+func pickKeys(q map[int64]int) (res []int64) {
+	for k := range q {
+		res = append(res, k)
+	}
+	return
+}

app/interface/main/tv/service/view/service.go

@@ -0,0 +1,49 @@
+package view
+
+import (
+	"context"
+
+	"go-common/app/interface/main/tv/conf"
+	"go-common/app/interface/main/tv/dao/account"
+	"go-common/app/interface/main/tv/dao/archive"
+	"go-common/app/interface/main/tv/dao/cms"
+	"go-common/app/interface/main/tv/dao/favorite"
+	"go-common/app/interface/main/tv/dao/upper"
+	"go-common/library/stat/prom"
+)
+
+// Service .
+type Service struct {
+	conf *conf.Config
+	// dao
+	arcDao *archive.Dao
+	accDao *account.Dao
+	cmsDao *cms.Dao
+	upDao  *upper.Dao
+	favDao *favorite.Dao
+	// prom
+	pHit       *prom.Prom
+	pMiss      *prom.Prom
+	prom       *prom.Prom
+	emptyArcCh chan int64
+}
+
+var ctx = context.TODO()
+
+// New .
+func New(c *conf.Config) *Service {
+	srv := &Service{
+		conf:       c,
+		arcDao:     archive.New(c),
+		accDao:     account.New(c),
+		cmsDao:     cms.New(c),
+		upDao:      upper.New(c),
+		favDao:     favorite.New(c),
+		pHit:       prom.CacheHit,
+		pMiss:      prom.CacheMiss,
+		prom:       prom.BusinessInfoCount,
+		emptyArcCh: make(chan int64, c.Cfg.EmptyArc.ChanSize),
+	}
+	go srv.emptyArcproc()
+	return srv
+}

app/interface/main/tv/service/view/view.go

@@ -0,0 +1,120 @@
+package view
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/tv/model"
+	upMdl "go-common/app/interface/main/tv/model/upper"
+	"go-common/app/interface/main/tv/model/view"
+	arcwar "go-common/app/service/main/archive/api"
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// View  all view data.
+func (s *Service) View(c context.Context, mid, aid int64, ak, ip string, now time.Time) (v *view.View, isok bool, errMsg string, err error) {
+	var (
+		arcMeta *model.ArcCMS
+		faved   bool
+		reginfo *arcwar.Tp
+	)
+	if arcMeta, isok, errMsg, err = s.ArcMsg(aid); err != nil { // arc auth msg, if not ok, we return the err msg
+		log.Info("View ArcMsg Aid:%d, Err:%v", aid, err)
+		return
+	} else if !isok {
+		return
+	}
+	if v, err = s.ViewPage(c, mid, aid, ak, ip, now); err != nil { // View page
+		if err == ecode.AccessDenied || err == ecode.NothingFound {
+			log.Warn("s.ViewPage() mid(%d) aid(%d) ak(%s) ip(%s) error(%v)",
+				mid, aid, ak, ip, err)
+			return
+		}
+		if err == ecode.TvAllDataAuditing { // the err is used to transport the message that all the data is being audited
+			isok, errMsg = s.cmsDao.AuditingMsg()
+			err = nil
+			return
+		}
+		log.Error("s.ViewPage() mid(%d) aid(%d) ak(%s) ip(%s) error(%v)",
+			mid, aid, ak, ip, err)
+		return
+	}
+	if reginfo, err = s.arcDao.TypeInfo(int32(arcMeta.TypeID)); err != nil {
+		log.Warn("s.arcDao.TypeInfo tid(%d) error(%v)", arcMeta.TypeID, err)
+	}
+	if reginfo != nil {
+		v.PID = reginfo.Pid
+	}
+	s.arcMetaInterv(v, arcMeta)  // cms interv
+	s.initRelates(c, v, ip, now) // get relates
+	v.ReqUser = &view.ReqUser{}
+	if faved, err = s.favDao.InDefault(c, mid, aid); err != nil {
+		log.Warn("s.favDao InDefault Mid %d, Aid %d, Err %v", mid, aid, err)
+	}
+	if faved {
+		v.ReqUser.Favorite = 1
+	}
+	return
+}
+
+// arcMetaInterv replaces view's archive info by arc cms meta info
+func (s *Service) arcMetaInterv(v *view.View, arcMeta *model.ArcCMS) {
+	if arcMeta == nil {
+		return
+	}
+	if arcMeta.Title != "" {
+		v.Static.Title = arcMeta.Title
+	}
+	if arcMeta.Cover != "" {
+		v.Static.Pic = arcMeta.Cover
+	}
+	if arcMeta.Content != "" {
+		v.Static.Desc = arcMeta.Content
+	}
+	// todo 分p的干预
+}
+
+// ViewPage view page data.
+func (s *Service) ViewPage(c context.Context, mid, aid int64, ak, ip string, now time.Time) (v *view.View, err error) {
+	var (
+		vs    *view.Static
+		vp    *arcwar.ViewReply
+		upper *upMdl.Upper
+	)
+	if vp, err = s.arcDao.GetView(c, aid); err != nil {
+		log.Error("ViewPage getView Aid:%d, Err:%v", aid, err)
+		return
+	}
+	if upper, err = s.upDao.LoadUpMeta(c, vp.Arc.Author.Mid); err != nil || !upper.CanShow() { // if upper can't be found or upper is not valid, hide it
+		vp.Arc.Author.Face = ""
+		vp.Arc.Author.Name = ""
+	} else { // if upper is valid, use cms info to show
+		vp.Arc.Author.Face = upper.CMSFace
+		vp.Arc.Author.Name = upper.CMSName
+	}
+	vs = &view.Static{Arc: vp.Arc}
+	if err = s.initPages(c, vs, vp.Pages); err != nil {
+		log.Error("ViewPage initPages Aid %d, Err %v", aid, err)
+		return
+	}
+	v = &view.View{Static: vs}
+	if v.AttrVal(archive.AttrBitIsPGC) != archive.AttrYes {
+		// check access
+		if err = s.checkAceess(c, mid, v.Aid, int(v.State), int(v.Access), ak, ip); err != nil {
+			// archive is ForbitFixed and Transcoding and StateForbitDistributing need analysis history body .
+			if v.State != archive.StateForbidFixed {
+				return
+			}
+			err = nil
+		}
+		if v.Access > 0 {
+			v.Stat.View = 0
+		}
+	}
+	if mid != 0 {
+		v.History, _ = s.arcDao.Progress(ctx, v.Aid, mid)
+	}
+	return
+}