Create & Init Project...

app/interface/main/tv/service/goblin/BUILD

@@ -0,0 +1,59 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "hotword.go",
+        "label.go",
+        "playurl.go",
+        "service.go",
+        "splash.go",
+        "upgrade.go",
+    ],
+    importpath = "go-common/app/interface/main/tv/service/goblin",
+    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/goblin:go_default_library",
+        "//app/interface/main/tv/model:go_default_library",
+        "//app/interface/main/tv/model/goblin:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/tv/api:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log: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"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["service_test.go"],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/tv/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/interface/main/tv/service/goblin/hotword.go

@@ -0,0 +1,24 @@
+package goblin
+
+import (
+	"time"
+
+	"go-common/library/log"
+)
+
+// reload hotword data from MC
+func (s *Service) loadHotword() {
+	var err error
+	if s.Hotword, err = s.dao.Hotword(ctx); err != nil {
+		log.Error("loadHotword Error %v, List %v", err, s.Hotword)
+		return
+	}
+}
+
+// load hotword data regularly
+func (s *Service) loadHotwordproc() {
+	for {
+		time.Sleep(time.Duration(s.conf.Search.HotwordFre))
+		s.loadHotword()
+	}
+}

app/interface/main/tv/service/goblin/label.go

@@ -0,0 +1,138 @@
+package goblin
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/tv/model"
+	"go-common/app/interface/main/tv/model/goblin"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_pgcLabel = 1
+	_ugcLabel = 2
+)
+
+func (s *Service) labelsproc() {
+	for {
+		time.Sleep(time.Duration(s.conf.Cfg.IndexLabel.Fre))
+		log.Info("Reload Label Data!")
+		s.prepareLabels()
+	}
+}
+
+// prepareLabels refreshes memory labels
+func (s *Service) prepareLabels() {
+	pgcLbs, errpgc := s.catLabels(_pgcLabel)
+	if errpgc != nil {
+		log.Error("loadLabels PGC Err %v", errpgc)
+		return
+	}
+	ugcLbs, errugc := s.catLabels(_ugcLabel)
+	if errugc != nil {
+		log.Error("loadLabels PGC Err %v", errugc)
+		return
+	}
+	if len(pgcLbs) > 0 && len(ugcLbs) > 0 {
+		s.labels = &goblin.IndexLabels{
+			PGC: pgcLbs,
+			UGC: ugcLbs,
+		}
+	}
+}
+
+// catLabels picks ugc/pgc all categories labels
+func (s *Service) catLabels(catType int) (result map[int][]*goblin.TypeLabels, err error) {
+	var (
+		cats    []int
+		typeMap map[int32]*model.ArcType
+	)
+	result = make(map[int][]*goblin.TypeLabels)
+	if catType == _pgcLabel {
+		cats = s.conf.Cfg.ZonesInfo.PGCZonesID
+	} else if catType == _ugcLabel {
+		if typeMap, err = s.arcDao.FirstTypes(); err != nil {
+			log.Error("loadLabels ArcDao FirstTypes Err %v", err)
+			return
+		}
+		for k := range typeMap {
+			cats = append(cats, int(k))
+		}
+	} else {
+		err = ecode.TvDangbeiWrongType
+		return
+	}
+	if len(cats) == 0 {
+		err = ecode.TvDangbeiPageNotExist
+		return
+	}
+	for _, category := range cats {
+		if result[category], err = s.loadLabels(catType, category); err != nil {
+			log.Error("loadLabels Err %v", err)
+			return
+		}
+	}
+	return
+}
+
+// getTypeLabel builds an typeLabels object from a slice of labels
+func getTypeLabel(in []*goblin.Label) *goblin.TypeLabels {
+	typeLbs := &goblin.TypeLabels{}
+	typeLbs.FromLabels(in)
+	return typeLbs
+}
+
+// loadLabels
+func (s *Service) loadLabels(catType, category int) (result []*goblin.TypeLabels, err error) {
+	var (
+		ctx       = context.Background()
+		labelMap  = make(map[string][]*goblin.Label)
+		labels    []*goblin.Label
+		showOrder []string
+		cfg       = s.conf.Cfg.IndexLabel
+	)
+	if labels, err = s.dao.Label(ctx, category, catType); err != nil {
+		log.Error("loadLabels Dao Label Cat %d, %d, Err %v", category, catType, err)
+		return
+	}
+	for _, v := range labels { // gather labels by their param
+		v.TransYear(cfg)
+		labelMap[v.Param] = append(labelMap[v.Param], v)
+	}
+	if catType == _pgcLabel {
+		showOrder = cfg.PGCOrder
+	} else {
+		showOrder = cfg.UGCOrder
+	}
+	for _, v := range showOrder {
+		if line, ok := labelMap[v]; ok {
+			result = append(result, getTypeLabel(line))
+			delete(labelMap, v)
+		}
+	}
+	if len(labelMap) > 0 {
+		for _, v := range labelMap {
+			result = append(result, getTypeLabel(v))
+		}
+	}
+	return
+}
+
+// Labels picks label
+func (s *Service) Labels(c context.Context, catType, category int) (result []*goblin.TypeLabels, err error) {
+	var (
+		indexLbs map[int][]*goblin.TypeLabels
+		ok       bool
+	)
+	if catType == _pgcLabel {
+		indexLbs = s.labels.PGC
+	} else {
+		indexLbs = s.labels.UGC
+	}
+	if result, ok = indexLbs[category]; !ok {
+		err = ecode.NothingFound
+	}
+	return
+}

app/interface/main/tv/service/goblin/playurl.go

@@ -0,0 +1,62 @@
+package goblin
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/interface/main/tv/model"
+	arcwar "go-common/app/service/main/archive/api"
+	tvapi "go-common/app/service/main/tv/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_tvVipOk = 1
+)
+
+// UgcPlayurl returns the result of ugc play url
+func (s *Service) UgcPlayurl(c context.Context, p *model.PlayURLReq, mid int64) (result map[string]interface{}, err error) {
+	var (
+		arc       *arcwar.Arc
+		firstRes  map[string]interface{}
+		firstResp *model.PlayURLResp
+		tvRes     *tvapi.UserInfoReply
+	)
+	result = make(map[string]interface{})
+	if firstRes, firstResp, err = s.dao.UgcPlayurl(c, p); err != nil {
+		return
+	}
+	if _, ok := s.VipQns[p.Qn]; !ok { // if it doesn't request vip quality, let it go
+		return firstRes, nil
+	}
+	if mid != 0 {
+		if tvRes, err = s.tvCilent.UserInfo(c, &tvapi.UserInfoReq{Mid: mid}); err != nil && !ecode.EqualError(ecode.NothingFound, err) {
+			log.Error("[playurl.UgcPlayurl] mid(%d) error(%s)", mid, err)
+			return
+		}
+		if tvRes != nil && tvRes.Status == _tvVipOk {
+			return firstRes, nil // if it's tv vip, let it go !
+		}
+		if arc, err = s.arcDao.Archive3(c, p.Avid); err != nil || arc == nil { // try author himself
+			log.Warn("s.arcDao.Archive3 failed can not view Aid %d, Mid %", p.Avid, mid)
+			return
+		}
+		if arc.Author.Mid == mid {
+			return firstRes, nil // if it's upper himself, let it go
+		}
+	}
+	// downgrade logic
+	for _, qn := range firstResp.AcceptQuality {
+		qnStr := fmt.Sprintf("%d", qn)
+		if _, ok := s.VipQns[qnStr]; ok { // if vip
+			continue
+		}
+		p.Qn = qnStr
+		result, _, err = s.dao.UgcPlayurl(c, p)
+		return
+	}
+	err = ecode.NothingFound // it doesn't have any other quality to allow downgrade
+	log.Error("Allow Quality %v, Err %v", firstResp.AcceptQuality, err)
+	return
+}

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

@@ -0,0 +1,55 @@
+package goblin
+
+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"
+	gobDao "go-common/app/interface/main/tv/dao/goblin"
+	"go-common/app/interface/main/tv/model"
+	"go-common/app/interface/main/tv/model/goblin"
+	tvapi "go-common/app/service/main/tv/api"
+)
+
+// Service .
+type Service struct {
+	conf      *conf.Config
+	dao       *gobDao.Dao
+	accDao    *account.Dao
+	arcDao    *archive.Dao
+	ChlSplash map[string]string // channel's splash data
+	Hotword   []*model.Hotword  // search hotword data
+	VipQns    map[string]int    // playurl qualities for vips
+	labels    *goblin.IndexLabels
+	tvCilent  tvapi.TVServiceClient
+}
+
+var ctx = context.TODO()
+
+// New .
+func New(c *conf.Config) *Service {
+	srv := &Service{
+		conf:      c,
+		dao:       gobDao.New(c),
+		ChlSplash: make(map[string]string),
+		VipQns:    make(map[string]int),
+		accDao:    account.New(c),
+		arcDao:    archive.New(c),
+		labels:    &goblin.IndexLabels{},
+	}
+	var err error
+	if srv.tvCilent, err = tvapi.NewClient(c.TvVipClient); err != nil {
+		panic(err)
+	}
+	for _, v := range c.Cfg.VipQns {
+		srv.VipQns[v] = 1
+	}
+	go srv.loadSph()         // splash
+	go srv.loadHotword()     // hotword
+	go srv.loadSphproc()     // splash proc
+	go srv.loadHotwordproc() // hotword proc
+	srv.prepareLabels()      // prepare index labels
+	go srv.labelsproc()
+	return srv
+}

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

@@ -0,0 +1,43 @@
+package goblin
+
+import (
+	"flag"
+	"fmt"
+	"path/filepath"
+	"testing"
+	"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)
+	}
+}
+
+func TestService_Labels(t *testing.T) {
+	Convey("TestService_Labels", t, WithService(func(s *Service) {
+		results, err := s.Labels(ctx, 1, 2)
+		So(err, ShouldBeNil)
+		So(results, ShouldNotBeNil)
+		for _, v := range results {
+			fmt.Println(v.ParamName)
+		}
+	}))
+}

app/interface/main/tv/service/goblin/splash.go

@@ -0,0 +1,53 @@
+package goblin
+
+import (
+	"time"
+
+	"go-common/app/interface/main/tv/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+func (s *Service) loadSphproc() {
+	for {
+		time.Sleep(time.Duration(s.conf.Cfg.PageReload))
+		log.Info("Reload Splash Data!")
+		s.loadSph()
+	}
+}
+
+func (s *Service) loadSph() {
+	var (
+		err       error
+		chls      []*model.Channel
+		chlSplash = make(map[string]string)
+	)
+	// pick channel's splash data
+	if chls, err = s.dao.ChlInfo(ctx); err != nil {
+		log.Error("LoadSph Error (%v)", err)
+		return
+	}
+	if len(chls) == 0 {
+		log.Error("loadSph Channel Data is Empty!")
+		return
+	}
+	// travel the channels to make the map
+	for _, v := range chls {
+		chlSplash[v.Title] = v.Splash
+	}
+	s.ChlSplash = chlSplash
+	log.Info("Reload %d Channel Data", len(chlSplash))
+}
+
+// PickSph picks the splash data from memory map
+func (s *Service) PickSph(channel string) (sph string, err error) {
+	var ok bool
+	if len(s.ChlSplash) == 0 {
+		log.Error("Channel Data is Nil")
+		return "", ecode.ServiceUnavailable
+	}
+	if sph, ok = s.ChlSplash[channel]; !ok {
+		sph = s.conf.Cfg.DefaultSplash
+	}
+	return sph, nil
+}

app/interface/main/tv/service/goblin/upgrade.go

@@ -0,0 +1,14 @@
+package goblin
+
+import (
+	"context"
+
+	"go-common/app/interface/main/tv/model"
+	"go-common/library/ecode"
+)
+
+// VerUpdate .
+func (s *Service) VerUpdate(c context.Context, ver *model.VerUpdate) (result *model.HTTPData, errCode ecode.Codes, err error) {
+	result, errCode, err = s.dao.VerUpdate(c, ver)
+	return
+}