Create & Init Project...

app/interface/main/tv/service/thirdp/BUILD

@@ -0,0 +1,63 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "dangbei_test.go",
+        "service_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/tv/conf:go_default_library",
+        "//app/interface/main/tv/dao/thirdp:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dangbei.go",
+        "mango.go",
+        "mango_recom.go",
+        "service.go",
+    ],
+    importpath = "go-common/app/interface/main/tv/service/thirdp",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/tv/conf: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/thirdp:go_default_library",
+        "//app/interface/main/tv/model:go_default_library",
+        "//app/interface/main/tv/model/thirdp:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//library/cache:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//vendor/github.com/pkg/errors: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/thirdp/dangbei.go

@@ -0,0 +1,105 @@
+package thirdp
+
+import (
+	"math"
+
+	"go-common/app/interface/main/tv/dao/thirdp"
+	"go-common/app/interface/main/tv/model"
+	tpMdl "go-common/app/interface/main/tv/model/thirdp"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/pkg/errors"
+)
+
+func (s *Service) buildPager(req *tpMdl.ReqDBeiPages) (pager *model.IdxPager, err error) {
+	var (
+		addCache bool
+		count    int
+	)
+	// pick up the count from redis, otherwise pick it from DB
+	if count, err = s.dao.GetThirdpCnt(ctx, req.TypeC); err != nil {
+		if count, err = s.dao.ThirdpCnt(ctx, req.TypeC); err != nil {
+			return // if db count still error, fatal error
+		}
+		log.Error("PickDBeiPage - Can't Get Count, Pass by DB, Page %d", req.Page)
+		addCache = true
+	}
+	pager = &model.IdxPager{
+		CurrentPage: int(req.Page),
+		TotalItems:  count,
+		TotalPages:  int(math.Ceil(float64(count) / float64(req.Ps))),
+		PageSize:    int(req.Ps),
+	}
+	if req.Page > int64(pager.TotalPages) {
+		err = ecode.TvDangbeiPageNotExist
+		return
+	}
+	// async Reset the DB data: Count & CurrentPage ID in MC for next time
+	if addCache {
+		cache.Save(func() {
+			s.dao.SetThirdpCnt(ctx, count, req.TypeC)
+			log.Info("PickDBeiPage Set Count %d Into Cache", count)
+		})
+	}
+	return
+}
+
+// PickDBeiPage picks the dangbei's page
+func (s *Service) PickDBeiPage(page int64, typeC string) (data *tpMdl.DBeiPage, err error) {
+	var (
+		cPageID int64
+		sids    []int64 // this page's season ids
+		sns     []*model.SeasonCMS
+		arcs    []*model.ArcCMS
+		dbeiSns []*tpMdl.DBeiSeason
+		pager   *model.IdxPager
+	)
+	req := &tpMdl.ReqDBeiPages{
+		Ps:    s.conf.Cfg.Dangbei.Pagesize,
+		TypeC: typeC,
+		Page:  page,
+	}
+	if pager, err = s.buildPager(req); err != nil {
+		return
+	}
+	if req.LastID, err = s.dao.LoadPageID(ctx, req); err != nil {
+		log.Error("MangoPage getPageID LastPage %d Miss, Pass by offset", page-1)
+		return
+	}
+	if sids, cPageID, err = s.dao.DBeiPages(ctx, req); err != nil {
+		return
+	}
+	if len(sids) == 0 {
+		err = errors.Wrapf(ecode.NothingFound, "Type_C [%s], Page [%d], Offset Result Empty", typeC, page)
+		return
+	}
+	// load data from cache and transform data to Dangbei structure
+	if typeC == thirdp.DBeiPGC { // pgc - seasonCMS
+		if sns, _, err = s.cmsDao.LoadSnsCMS(ctx, sids); err != nil {
+			log.Error("PickDBeiPage - PGC - LoadSnsCMS - Sids %v, Error %v", sids, err)
+			return
+		}
+		for _, v := range sns { // transform the object to DbeiSeason
+			dbeiSns = append(dbeiSns, tpMdl.DBeiSn(v))
+		}
+	} else if typeC == thirdp.DBeiUGC { // ugc - arcCMS
+		if arcs, err = s.cmsDao.LoadArcsMedia(ctx, sids); err != nil {
+			log.Error("PickDBeiPage - UGC - LoadArcsMedia - Sids %v, Error %v", sids, err)
+			return
+		}
+		for _, v := range arcs {
+			first, second := s.arcDao.GetPTypeName(int32(v.TypeID))
+			dbeiSns = append(dbeiSns, tpMdl.DbeiArc(v, first, second))
+		}
+	}
+	// async Reset the DB data: CurrentPage ID in MC for next time
+	cache.Save(func() {
+		s.dao.SetPageID(ctx, &tpMdl.ReqPageID{Page: page, ID: cPageID, TypeC: typeC})
+	})
+	data = &tpMdl.DBeiPage{
+		List:  dbeiSns,
+		Pager: pager,
+	}
+	return
+}

app/interface/main/tv/service/thirdp/dangbei_test.go

@@ -0,0 +1,41 @@
+package thirdp
+
+import (
+	"fmt"
+	"testing"
+
+	"encoding/json"
+
+	"go-common/app/interface/main/tv/dao/thirdp"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_PickDBeiPage(t *testing.T) {
+	Convey("TestService_PickDBeiPage", t, WithService(func(s *Service) {
+		data, err := s.PickDBeiPage(0, thirdp.DBeiUGC)
+		So(err, ShouldBeNil)
+		So(data, ShouldNotBeNil)
+		fmt.Println(data)
+	}))
+}
+
+func TestService_MangoSns(t *testing.T) {
+	Convey("TestService_MangoSns", t, WithService(func(s *Service) {
+		data, err := s.MangoSns(ctx, 7)
+		So(err, ShouldBeNil)
+		So(data, ShouldNotBeNil)
+		str, _ := json.Marshal(data)
+		fmt.Println(string(str))
+	}))
+}
+
+func TestService_MangoArcs(t *testing.T) {
+	Convey("TestService_MangoArcs", t, WithService(func(s *Service) {
+		data, err := s.MangoArcs(ctx, 3)
+		So(err, ShouldBeNil)
+		So(data, ShouldNotBeNil)
+		str, _ := json.Marshal(data)
+		fmt.Println(string(str))
+	}))
+}

app/interface/main/tv/service/thirdp/mango.go

@@ -0,0 +1,262 @@
+package thirdp
+
+import (
+	"context"
+	"math"
+
+	"go-common/app/interface/main/tv/dao/thirdp"
+	"go-common/app/interface/main/tv/model"
+	tpMdl "go-common/app/interface/main/tv/model/thirdp"
+	arcwar "go-common/app/service/main/archive/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/pkg/errors"
+)
+
+// mangoPage picks the Mango's page
+func (s *Service) mangoPage(page int64, typeC string) (pager *model.IdxPager, dataSet []*tpMdl.RespSid, err error) {
+	var (
+		cPageID int64
+		req     = &tpMdl.ReqDBeiPages{
+			Page:  page,
+			TypeC: typeC,
+			Ps:    int64(s.conf.Cfg.Dangbei.MangoPS),
+		}
+	)
+	if pager, err = s.buildPager(req); err != nil {
+		return
+	}
+	if req.LastID, err = s.dao.LoadPageID(ctx, req); err != nil {
+		log.Error("MangoPage getPageID Page %d Miss, Pass by offset", page-1)
+		return
+	}
+	if dataSet, cPageID, err = s.dao.MangoPages(ctx, req); err != nil {
+		return
+	}
+	if len(dataSet) == 0 {
+		err = errors.Wrapf(ecode.NothingFound, "Type_C [%s], Page [%d], Offset Result Empty", typeC, page)
+		return
+	}
+	cache.Save(func() {
+		s.dao.SetPageID(ctx, &tpMdl.ReqPageID{Page: page, ID: cPageID, TypeC: typeC})
+	})
+	return
+}
+
+// MangoSns picks mango season pages
+func (s *Service) MangoSns(ctx context.Context, page int64) (data *tpMdl.MangoSnPage, err error) {
+	var (
+		pager       *model.IdxPager
+		dataSet     []*tpMdl.RespSid
+		snMetas     = map[int64]*model.SeasonCMS{}
+		snAuths     = map[int64]*model.SnAuth{}
+		newestEpids []int64
+		epMetas     = map[int64]*model.EpCMS{}
+	)
+	if pager, dataSet, err = s.mangoPage(page, thirdp.MangoPGC); err != nil {
+		return
+	}
+	data = &tpMdl.MangoSnPage{
+		Pager: pager,
+	}
+	sids := tpMdl.PickSids(dataSet)
+	if snMetas, err = s.cmsDao.LoadSnsCMSMap(ctx, sids); err != nil {
+		log.Error("MangoSns - PGC - LoadSnsCMS - Sids %v, Error %v", sids, err)
+		return
+	}
+	if snAuths, err = s.cmsDao.LoadSnsAuthMap(ctx, sids); err != nil {
+		log.Error("MangoSns - PGC - LoadSnsAuthMap - Sids %v, Error %v", sids, err)
+		return
+	}
+	for _, v := range snMetas { // pick newestEpids
+		if v.NewestEPID != 0 {
+			newestEpids = append(newestEpids, v.NewestEPID)
+		}
+	}
+	if len(newestEpids) > 0 { // pick eps cms meta info
+		if epMetas, err = s.cmsDao.LoadEpsCMS(ctx, newestEpids); err != nil {
+			log.Error("MangoSns - PGC - LoadEpsCMS - Epids %v, Error %v", newestEpids, err)
+			return
+		}
+	}
+	for _, v := range dataSet { // transform the object to DbeiSeason
+		var (
+			snMeta         *model.SeasonCMS
+			snAuth         *model.SnAuth
+			okMeta, okAuth bool
+		)
+		if snMeta, okMeta = snMetas[v.Sid]; okMeta {
+			if snAuth, okAuth = snAuths[v.Sid]; okAuth {
+				mangoSn := tpMdl.ToMangoSn(snMeta, v.Mtime, snAuth.CanPlay())
+				if newestEp := snMeta.NewestEPID; newestEp != 0 {
+					if epMeta, ok := epMetas[snMeta.NewestEPID]; ok {
+						mangoSn.EpCover = epMeta.Cover
+					}
+				}
+				data.List = append(data.List, mangoSn)
+				continue
+			}
+		}
+		log.Warn("MangoSns Sid %d Missing Info, Meta %v, Auth %v", v.Sid, okMeta, okAuth)
+	}
+	return
+}
+
+// MangoArcs picks mango archive pages
+func (s *Service) MangoArcs(ctx context.Context, page int64) (data *tpMdl.MangoArcPage, err error) {
+	var (
+		pager    *model.IdxPager
+		dataSet  []*tpMdl.RespSid
+		arcMetas map[int64]*model.ArcCMS
+	)
+	if pager, dataSet, err = s.mangoPage(page, thirdp.MangoUGC); err != nil {
+		return
+	}
+	data = &tpMdl.MangoArcPage{
+		Pager: pager,
+	}
+	sids := tpMdl.PickSids(dataSet)
+	if arcMetas, err = s.cmsDao.LoadArcsMediaMap(ctx, sids); err != nil {
+		log.Error("MangoArcs - UGC - LoadArcsMediaMap - Sids %v, Error %v", sids, err)
+		return
+	}
+	for _, v := range dataSet { // transform the object to DbeiSeason
+		if arcMeta, ok := arcMetas[v.Sid]; ok {
+			cat1, cat2 := s.arcDao.GetPTypeName(int32(arcMeta.TypeID))
+			data.List = append(data.List, tpMdl.ToMangoArc(arcMeta, v.Mtime, cat1, cat2))
+			continue
+		}
+		log.Warn("MangoSns Aid %d Missing Info", v.Sid)
+	}
+	return
+}
+
+// MangoEps returns mango eps data
+func (s *Service) MangoEps(ctx context.Context, sid int64, page int) (data *tpMdl.MangoEpPage, err error) {
+	var (
+		count    int
+		pagesize = s.conf.Cfg.Dangbei.MangoPS
+		resp     []*tpMdl.RespSid
+		epMetas  map[int64]*model.EpCMS
+		epAuths  map[int64]*model.EpAuth
+	)
+	if count, err = s.dao.LoadSnCnt(ctx, true, sid); err != nil {
+		log.Error("MangoEps LoadSnCnt Sid %d, Err %v", sid, err)
+		return
+	}
+	totalPages := int(math.Ceil(float64(count) / float64(pagesize)))
+	if page > totalPages {
+		return nil, ecode.TvDangbeiPageNotExist
+	}
+	data = &tpMdl.MangoEpPage{
+		SeasonID: sid,
+		Pager: &model.IdxPager{
+			CurrentPage: page,
+			TotalItems:  count,
+			TotalPages:  int(math.Ceil(float64(count) / float64(pagesize))),
+			PageSize:    int(pagesize),
+		},
+	}
+	if resp, err = s.dao.MangoSnOffset(ctx, true, sid, page, pagesize); err != nil {
+		log.Error("MangoEps MangoSnOffset Sid %d, Err %v", sid, err)
+		return
+	}
+	epids := tpMdl.PickSids(resp)
+	if epMetas, err = s.cmsDao.LoadEpsCMS(ctx, epids); err != nil {
+		log.Error("MangoEps LoadEpsCMS Sid %d, Err %v", sid, err)
+		return
+	}
+	if epAuths, err = s.cmsDao.LoadEpsAuthMap(ctx, epids); err != nil {
+		log.Error("MangoEps LoadEpsAuthMap Sid %d, Err %v", sid, err)
+		return
+	}
+	for _, v := range resp {
+		var (
+			epMeta         *model.EpCMS
+			epAuth         *model.EpAuth
+			okMeta, okAuth bool
+		)
+		if epMeta, okMeta = epMetas[v.Sid]; okMeta {
+			if epAuth, okAuth = epAuths[v.Sid]; okAuth {
+				data.List = append(data.List, &tpMdl.MangoEP{
+					EpCMS:     *epMeta,
+					SeasonID:  sid,
+					Mtime:     v.Mtime,
+					Autorised: epAuth.CanPlay(),
+				})
+				continue
+			}
+		}
+		log.Warn("MangoEps Sid %d, Epids %d Missing Info, Meta %v, Auth %v", sid, v.Sid, okMeta, okAuth)
+	}
+	return
+}
+
+// MangoVideos returns mango videos data
+func (s *Service) MangoVideos(ctx context.Context, sid int64, page int) (data *tpMdl.MangoVideoPage, err error) {
+	var (
+		count      int
+		pagesize   = s.conf.Cfg.Dangbei.MangoPS
+		resp       []*tpMdl.RespSid
+		videoMetas map[int64]*model.VideoCMS
+		vp         *arcwar.ViewReply
+		vPages     = make(map[int64]*arcwar.Page)
+	)
+	if count, err = s.dao.LoadSnCnt(ctx, false, sid); err != nil {
+		log.Error("MangoVideos LoadSnCnt Sid %d, Err %v", sid, err)
+		return
+	}
+	totalPages := int(math.Ceil(float64(count) / float64(pagesize)))
+	if page > totalPages {
+		return nil, ecode.TvDangbeiPageNotExist
+	}
+	data = &tpMdl.MangoVideoPage{
+		AVID: sid,
+		Pager: &model.IdxPager{
+			CurrentPage: page,
+			TotalItems:  count,
+			TotalPages:  int(math.Ceil(float64(count) / float64(pagesize))),
+			PageSize:    int(pagesize),
+		},
+	}
+	if resp, err = s.dao.MangoSnOffset(ctx, false, sid, page, pagesize); err != nil {
+		log.Error("MangoVideos MangoSnOffset Sid %d, Err %v", sid, err)
+		return
+	}
+	epids := tpMdl.PickSids(resp)
+	if videoMetas, err = s.cmsDao.LoadVideosMeta(ctx, epids); err != nil {
+		log.Error("MangoVideos LoadEpsCMS Sid %d, Err %v", sid, err)
+		return
+	}
+	if vp, err = s.arcDao.GetView(ctx, sid); err != nil {
+		log.Error("MangoVideos ViewPage getView Aid:%d, Err:%v", sid, err)
+		return
+	}
+	for _, v := range vp.Pages {
+		vPages[v.Cid] = v
+	}
+	for _, v := range resp {
+		var (
+			vMeta          *model.VideoCMS
+			view           *arcwar.Page
+			okMeta, okView bool
+		)
+		if vMeta, okMeta = videoMetas[v.Sid]; okMeta {
+			if view, okView = vPages[v.Sid]; okView {
+				data.List = append(data.List, &tpMdl.MangoVideo{
+					CID:       v.Sid,
+					Page:      vMeta.IndexOrder,
+					Desc:      view.Desc,
+					Title:     vMeta.Title,
+					Duration:  view.Duration,
+					Autorised: vMeta.CanPlay(),
+					Mtime:     v.Mtime,
+				})
+				continue
+			}
+		}
+		log.Warn("MangoViews Sid %d, Epids %d Missing Info, Meta %v, View %v", sid, v.Sid, okMeta, okView)
+	}
+	return
+}

app/interface/main/tv/service/thirdp/mango_recom.go

@@ -0,0 +1,90 @@
+package thirdp
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/tv/model"
+	tpMdl "go-common/app/interface/main/tv/model/thirdp"
+	arcwar "go-common/app/service/main/archive/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_rtypePGC = 1
+	_rtypeUGC = 2
+)
+
+func (s *Service) mangoR() (err error) {
+	var (
+		ctx     = context.Background()
+		rids    []int64
+		recoms  []*tpMdl.MangoRecom
+		params  []*tpMdl.MangoParams
+		catInfo *arcwar.Tp
+	)
+	if rids, err = s.dao.MangoOrder(ctx); err != nil { // pick mango recoms' order
+		log.Error("mango MangoOrder Error %v", err)
+		return
+	}
+	if len(rids) == 0 {
+		log.Error("mango MangoOrder Empty")
+		return
+	}
+	if recoms, err = s.dao.MangoRecom(ctx, rids); err != nil { // pick mango recom data
+		log.Error("mango MangoRecom Rids [%v], Err %v", rids, err)
+		return
+	}
+	for _, recom := range recoms {
+		if recom.Rtype == _rtypePGC {
+			var sn *model.SeasonCMS
+			if sn, err = s.cmsDao.LoadSnCMS(context.Background(), recom.RID); err != nil {
+				return err
+			}
+			param := recom.ToParam()
+			param.Category = tpMdl.PgcCat(recom.Category)
+			param.Role = sn.Role
+			param.PlayTime = sn.Playtime.Time().Format("2006-01-02")
+			params = append(params, param)
+		} else if recom.Rtype == _rtypeUGC {
+			var arc *model.ArcCMS
+			if arc, err = s.cmsDao.LoadArcMeta(context.Background(), recom.RID); err != nil {
+				return err
+			}
+			param := recom.ToParam()
+			if catInfo, err = s.arcDao.TypeInfo(int32(recom.Category)); err != nil { // pick ugc category name
+				log.Warn("MangoRecom Recom RID %d, Cat %d", recom.RID, recom.Category)
+			} else {
+				param.Category = catInfo.Name
+			}
+			param.PlayTime = arc.Pubtime.Time().Format("2006-01-02")
+			params = append(params, param)
+		} else {
+			return ecode.TvDangbeiWrongType
+		}
+	}
+	if len(params) > 0 {
+		s.mangoRecom = params
+	}
+	return
+}
+
+func (s *Service) mangorproc() {
+	for {
+		time.Sleep(time.Duration(s.conf.Cfg.PageReload))
+		if err := s.mangoR(); err != nil {
+			log.Error("mango Error %v", err)
+		}
+	}
+}
+
+// MangoRecom returns the mango recom data
+func (s *Service) MangoRecom() (data []*tpMdl.MangoParams) {
+	if len(s.mangoRecom) == 0 {
+		data = make([]*tpMdl.MangoParams, 0)
+		return
+	}
+	data = s.mangoRecom
+	return
+}

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

@@ -0,0 +1,45 @@
+package thirdp
+
+import (
+	"context"
+
+	"go-common/app/interface/main/tv/conf"
+	"go-common/app/interface/main/tv/dao/archive"
+	cmsDao "go-common/app/interface/main/tv/dao/cms"
+	"go-common/app/interface/main/tv/dao/thirdp"
+	tpMdl "go-common/app/interface/main/tv/model/thirdp"
+	xcache "go-common/library/cache"
+)
+
+var (
+	ctx   = context.Background()
+	cache *xcache.Cache
+)
+
+func init() {
+	cache = xcache.New(1, 1024)
+}
+
+// Service .
+type Service struct {
+	dao        *thirdp.Dao
+	cmsDao     *cmsDao.Dao
+	arcDao     *archive.Dao
+	conf       *conf.Config
+	mangoRecom []*tpMdl.MangoParams // mango recom data
+}
+
+// New .
+func New(c *conf.Config) *Service {
+	srv := &Service{
+		// dao
+		dao:    thirdp.New(c),
+		cmsDao: cmsDao.New(c),
+		arcDao: archive.New(c),
+		// config
+		conf: c,
+	}
+	go srv.mangorproc() // load mango recom data
+	srv.mangoR()
+	return srv
+}

app/interface/main/tv/service/thirdp/service_test.go

@@ -0,0 +1,30 @@
+package thirdp
+
+import (
+	"flag"
+	"path/filepath"
+	"time"
+
+	"go-common/app/interface/main/tv/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	srv *Service
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/tv-interface.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	srv = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func WithService(f func(s *Service)) func() {
+	return func() {
+		Reset(func() {})
+		f(srv)
+	}
+}